Clear main before restore

README.md

@@ -1,6 +0,0 @@
----
-tags:
-- ml-intern
----
-
-# bep40/VNEWS

ai_ext.py

@@ -1,574 +0,0 @@
-"""VNEWS AI Extension - rewrite + auto short video generation.
-Imported by app_v2_entry.py to register /api/rewrite_share, /api/topic_post,
-/api/ai_wall, /api/wall, /api/ai/short endpoints on the main FastAPI app.
-
-Uses main.py's WALL_FILE (wall_posts.json) for unified data store.
-TTS: edge-tts (HoaiMy female, NamMinh male) with speed control + gTTS fallback.
-"""
-import os, re, json, time, random, html as html_lib, subprocess, asyncio
-from urllib.parse import quote_plus, quote, urlparse, urljoin
-from typing import Optional, List, Dict
-import requests
-from bs4 import BeautifulSoup
-from fastapi import Request, Query
-from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
-
-# Try to import main app, but don't fail if it doesn't exist
-try:
-    from main import app
-except ImportError:
-    # Create a minimal FastAPI app for standalone testing
-    try:
-        from fastapi import FastAPI
-        app = FastAPI()
-    except Exception:
-        app = None
-
-# Import wall store from main.py so we read/write the SAME file
-try:
-    from main import _load_wall, _save_wall, _web_context  # noqa: F401
-except ImportError:
-    _data_dir = "/data" if os.path.isdir("/data") else "/app/data"
-    _wall_file = os.path.join(_data_dir, "wall_posts.json")
-    def _load_wall():
-        try:
-            if os.path.exists(_wall_file):
-                with open(_wall_file, "r", encoding="utf-8") as f:
-                    return json.load(f)
-        except Exception:
-            pass
-        return []
-    def _save_wall(posts):
-        try:
-            os.makedirs(os.path.dirname(_wall_file), exist_ok=True)
-            tmp = _wall_file + ".tmp"
-            with open(tmp, "w", encoding="utf-8") as f:
-                json.dump(posts[:100], f, ensure_ascii=False)
-            os.replace(tmp, _wall_file)
-        except Exception:
-            pass
-    def _web_context(topic):
-        return ""
-
-# ai_ext alias for backward compatibility
-_load_ai_wall = _load_wall
-_save_ai_wall = _save_wall
-
-try:
-    from huggingface_hub import AsyncInferenceClient
-except Exception:
-    AsyncInferenceClient = None
-try:
-    from gtts import gTTS
-except Exception:
-    gTTS = None
-try:
-    from PIL import Image, ImageDraw, ImageFont
-except Exception:
-    Image = ImageDraw = ImageFont = None
-try:
-    import edge_tts
-except Exception:
-    edge_tts = None
-
-
-def _hf_token():
-    for k in ("HF_TOKEN", "HUGGINGFACE_HUB_API_TOKEN", "HUGGING_FACE_HUB_TOKEN", "HF_API_TOKEN"):
-        v = os.getenv(k, "").strip()
-        if v:
-            return v
-    return ""
-
-
-def _clean_text(s: str) -> str:
-    """Clean text for processing."""
-    s = html_lib.unescape(s or "")
-    s = re.sub(r"\s+", " ", s)
-    return s.strip()
-
-
-def _domain(url: str) -> str:
-    """Extract domain from URL."""
-    try:
-        return urlparse(url or "").netloc.replace("www.", "")
-    except Exception:
-        return ""
-
-
-async def qwen_generate(prompt: str, image_url: str = None, max_tokens: int = 1200) -> str:
-    """Generate text using Qwen models via Hugging Face Inference API.
-    
-    This function provides a resilient implementation that:
-    1. First tries the SDK-based inference client if available
-    2. Falls back to REST API calls to HF router endpoint
-    3. Returns a fallback summary if all else fails
-    """
-    token = _hf_token()
-    errors = []
-    
-    # Try HF router API with multiple models
-    if token:
-        models = [
-            os.getenv("QWEN_VL_MODEL", ""),
-            "Qwen/Qwen2.5-VL-7B-Instruct",
-            "Qwen/Qwen2.5-VL-3B-Instruct", 
-            "Qwen/Qwen2.5-7B-Instruct",
-            "Qwen/Qwen2.5-3B-Instruct",
-            "Qwen/Qwen2.5-1.5B-Instruct",
-            "Qwen/Qwen2.5-72B-Instruct",
-            "meta-llama/Llama-3.3-70B-Instruct",
-        ]
-        # Deduplicate while preserving order
-        seen = set()
-        models = [m for m in models if m and m not in seen and not seen.add(m)]
-        
-        headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
-        
-        for model in models:
-            try:
-                is_vl = "VL" in model and image_url
-                if is_vl:
-                    user_content = [
-                        {"type": "image_url", "image_url": {"url": image_url}},
-                        {"type": "text", "text": prompt}
-                    ]
-                else:
-                    user_content = prompt
-                
-                payload = {
-                    "model": model,
-                    "messages": [
-                        {"role": "system", "content": "Bạn là trợ lý AI tiếng Việt. Trả lời tự nhiên, ngắn gọn, chính xác."},
-                        {"role": "user", "content": user_content},
-                    ],
-                    "max_tokens": min(int(max_tokens or 900), 1400),
-                    "temperature": 0.35,
-                    "top_p": 0.85,
-                }
-                
-                r = requests.post(
-                    "https://router.huggingface.co/v1/chat/completions",
-                    headers=headers,
-                    json=payload,
-                    timeout=95
-                )
-                
-                if r.status_code >= 300:
-                    errors.append(f"{model}: HTTP {r.status_code}")
-                    continue
-                    
-                j = r.json()
-                txt = (j.get("choices", [{}])[0].get("message", {}).get("content") or "").strip()
-                
-                if txt:
-                    return txt
-                    
-                errors.append(f"{model}: empty response")
-                
-            except Exception as e:
-                errors.append(f"{model}: {type(e).__name__}")
-    
-    # Fallback: extractive summary from prompt
-    LAST_QWEN_ERROR = errors[-3:] if errors else "unknown error"
-    return _fallback_summary_from_prompt(prompt, max_units=6)
-
-
-def _fallback_summary_from_prompt(prompt: str, max_units: int = 6) -> str:
-    """Generate a simple fallback summary when AI is unavailable."""
-    text = prompt or ""
-    for marker in ["Nội dung nguồn:", "Nội dung bài:", "Nội dung gốc:", "Nội dung:", "Nguồn/bối cảnh internet:"]:
-        if marker in text:
-            text = text.split(marker, 1)[1]
-            break
-    text = re.sub(r"https?://\S+", "", text)
-    text = re.sub(r"\s+", " ", text).strip()
-    
-    # Split into sentences - extract ALL valid sentences, not just first few
-    sentences = re.split(r"(?<=[.!?])\s+(?=[A-ZÀ-Ỹ0-9])", text)
-    units = []
-    for s in sentences:
-        s = _clean_text(s)
-        if len(s) >= 30:  # Lower threshold to capture more content
-            units.append(s)
-    
-    if units:
-        # Take up to max_units valid sentences
-        result_units = units[:max_units]
-        return "\n".join("• " + u for u in result_units)
-    if text:
-        # Fallback: take chunks if no sentence boundaries found
-        chunks = []
-        for i in range(0, min(len(text), max_units * 300), 280):
-            chunk = _clean_text(text[i:i+300])
-            if chunk and chunk not in chunks:
-                chunks.append(chunk)
-                if len(chunks) >= max_units:
-                    break
-        if chunks:
-            return "\n".join("• " + c for c in chunks)
-    return "• Không có đủ nội dung để tóm tắt."
-
-
-HF_TOKEN = _hf_token()
-QWEN_VL_MODEL = os.getenv("QWEN_VL_MODEL", "Qwen/Qwen2.5-VL-7B-Instruct")
-QWEN_TEXT_MODELS = [m.strip() for m in os.getenv(
-    "QWEN_TEXT_MODELS",
-    "Qwen/Qwen2.5-72B-Instruct,meta-llama/Llama-3.3-70B-Instruct,Qwen/Qwen2.5-7B-Instruct"
-).split(",") if m.strip()]
-_WORKING_MODEL_TEXT = None
-_WORKING_MODEL_VL = None
-DATA_DIR = "/data" if os.path.isdir("/data") else "/app/data"
-SHORTS_DIR = os.path.join(DATA_DIR, "ai_shorts")
-HEADERS = {
-    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
-    "Accept-Language": "vi-VN,vi;q=0.9,en;q=0.8"
-}
-LAST_QWEN_ERROR = ""
-
-
-# ===== MULTILINGUAL VOICES FOR TTS =====
-# Maps voice IDs to edge-tts voice names (only MultilingualNeural voices)
-MULTILINGUAL_VOICES = {
-    # Vietnamese - Native voices
-    "vi-vn-hoaimyneural": "vi-VN-HoaiMyNeural",
-    "vi-vn-namminhneural": "vi-VN-NamMinhNeural",
-    "hoaimy": "vi-VN-HoaiMyNeural",
-    "namminh": "vi-VN-NamMinhNeural",
-    "vi_female": "vi-VN-HoaiMyNeural",
-    "vi_male": "vi-VN-NamMinhNeural",
-    "nu": "vi-VN-HoaiMyNeural",
-    "male": "vi-VN-NamMinhNeural",
-    "female": "vi-VN-HoaiMyNeural",
-    "mien-nam": "vi-VN-HoaiMyNeural",
-    # English - Multilingual
-    "en-us-andrewmultilingualneural": "en-US-AndrewMultilingualNeural",
-    "en-au-williammultilingualneural": "en-AU-WilliamMultilingualNeural",
-    "en_andrew": "en-US-AndrewMultilingualNeural",
-    "andrew": "en-US-AndrewMultilingualNeural",
-    "en_jenny": "en-US-AndrewMultilingualNeural",
-    "jenny": "en-US-AndrewMultilingualNeural",
-    # Portuguese - Thalita Multilingual ONLY
-    "pt-br-thalitamultilingualneural": "pt-BR-ThalitaMultilingualNeural",
-    "pt_thalita": "pt-BR-ThalitaMultilingualNeural",
-    "thalita": "pt-BR-ThalitaMultilingualNeural",
-    "pt_francisco": "pt-BR-ThalitaMultilingualNeural",
-    "pt": "pt-BR-ThalitaMultilingualNeural",
-    # French - Multilingual
-    "fr-fr-viviennemultilingualneural": "fr-FR-VivienneMultilingualNeural",
-    "fr-fr-remymultilingualneural": "fr-FR-RemyMultilingualNeural",
-    "fr_denise": "fr-FR-VivienneMultilingualNeural",
-    "denise": "fr-FR-VivienneMultilingualNeural",
-    "fr": "fr-FR-VivienneMultilingualNeural",
-    # German - Multilingual
-    "de-de-seraphinamultilingualneural": "de-DE-SeraphinaMultilingualNeural",
-    "de-de-florianmultilingualneural": "de-DE-FlorianMultilingualNeural",
-    "de_katja": "de-DE-SeraphinaMultilingualNeural",
-    "katja": "de-DE-SeraphinaMultilingualNeural",
-    "de": "de-DE-SeraphinaMultilingualNeural",
-    # Korean - Hyunsu Multilingual (NOT SunHee)
-    "ko-kr-hyunsumultilingualneural": "ko-KR-HyunsuMultilingualNeural",
-    "ko_sunhee": "ko-KR-HyunsuMultilingualNeural",
-    "sunhee": "ko-KR-HyunsuMultilingualNeural",
-    "ko": "ko-KR-HyunsuMultilingualNeural",
-    # Italian - Multilingual
-    "it-it-giuseppemultilingualneural": "it-IT-GiuseppeMultilingualNeural",
-    # Spanish (fallback to English multilingual)
-    "es_ela": "en-US-AndrewMultilingualNeural",
-    "ela": "en-US-AndrewMultilingualNeural",
-    "es_carlos": "en-US-AndrewMultilingualNeural",
-    "es": "en-US-AndrewMultilingualNeural",
-    # Japanese (fallback to English multilingual)
-    "ja_nanami": "en-US-AndrewMultilingualNeural",
-    "nanami": "en-US-AndrewMultilingualNeural",
-    "ja": "en-US-AndrewMultilingualNeural",
-    # Chinese (fallback to English multilingual)
-    "zh_xiaochen": "en-US-AndrewMultilingualNeural",
-    "xiaochen": "en-US-AndrewMultilingualNeural",
-    "zh": "en-US-AndrewMultilingualNeural",
-}
-
-
-def _detect_voice_emotion(title, text):
-    """Detect appropriate voice and emotion based on content for multilingual TTS."""
-    content = ((title or "") + " " + (text or "")).lower()
-    
-    # World Cup / Football content - use Andrew multilingual
-    if any(kw in content for kw in ["world cup", "wc 2026", "fifa", "bóng đá", "trận đấu", "bóng bóng", "đội tuyển", "cầu thủ"]):
-        return ("andrew", "excited")
-    
-    # News categories - choose appropriate voice
-    if any(kw in content for kw in ["kinh tế", "tài chính", "thị trường", "economics", "finance"]):
-        return ("jenny", "calm")
-    if any(kw in content for kw in ["thiên tai", "bão", "lũ lụt", "cháy nổ", "tai nạn", "disaster", "accident"]):
-        return ("thalita", "serious")
-    if any(kw in content for kw in ["giải trí", "showbiz", "entertainment", "hài hước"]):
-        return ("ela", "happy")
-    if any(kw in content for kw in ["công nghệ", "tech", "technology", "ai", "trí tuệ nhân tạo"]):
-        return ("katja", "excited")
-    
-    # Default Vietnamese
-    return ("hoaimy", "trung_tinh")
-
-
-def _safe_name(s: str) -> str:
-    """Create safe filename from string."""
-    s = re.sub(r"[^\w\-.]", "_", s)
-    return s[:100] if len(s) > 100 else s
-
-
-def _download_image(url: str, fallback_title: str, out_path: str) -> bool:
-    """Download image from URL to path."""
-    if not url:
-        return False
-    try:
-        r = requests.get(url, headers=HEADERS, timeout=15)
-        if r.status_code == 200:
-            os.makedirs(os.path.dirname(out_path), exist_ok=True)
-            with open(out_path, "wb") as f:
-                f.write(r.content)
-            return True
-    except Exception:
-        pass
-    return False
-
-
-def pollination_image_url(topic: str) -> str:
-    """Generate image URL from Pollinations.ai."""
-    return f"https://image.pollinations.ai/prompt/{quote(topic)}?width=1024&height=768&nologo=true&model=flux"
-
-
-# Use the same wall file as app_v2_entry.py for consistency
-WALL_FILE = os.path.join(DATA_DIR, "wall_posts.json")
-
-def _load_ai_wall():
-    """Load AI wall posts from JSON file (uses wall_posts.json for consistency with app_v2_entry)."""
-    try:
-        if os.path.exists(WALL_FILE):
-            with open(WALL_FILE, "r", encoding="utf-8") as f:
-                return json.load(f)
-    except Exception:
-        pass
-    return []
-
-
-def _save_ai_wall(posts):
-    """Save AI wall posts to JSON file (uses wall_posts.json for consistency with app_v2_entry)."""
-    try:
-        os.makedirs(os.path.dirname(WALL_FILE), exist_ok=True)
-        tmp = WALL_FILE + ".tmp"
-        with open(tmp, "w", encoding="utf-8") as f:
-            json.dump(posts[:100], f, ensure_ascii=False)
-        os.replace(tmp, WALL_FILE)
-    except Exception:
-        pass
-
-
-# Helper functions for wall operations
-def _load_wall_posts():
-    """Alias for _load_ai_wall for consistency with app_v2_entry.py."""
-    return _load_ai_wall()
-
-
-def _save_wall_posts(posts):
-    """Alias for _save_ai_wall for consistency with app_v2_entry.py."""
-    return _save_ai_wall(posts)
-
-
-def make_post(title: str, text: str, img: str, url: str, kind: str, sources=None):
-    """Create a post dict with standard fields."""
-    return {
-        "id": str(int(time.time() * 1000)),
-        "title": title,
-        "text": text,
-        "img": img,
-        "url": url,
-        "kind": kind,
-        "sources": sources or [],
-        "ts": int(time.time())
-    }
-
-
-def _short_script(post) -> str:
-    """Extract clean text for TTS from post."""
-    text = post.get("text", "") or post.get("title", "")
-    text = re.sub(r"^[•\-\*]\s*", "", text, flags=re.M)
-    text = re.sub(r"\s*\n\s*", ". ", text)
-    return _clean_text(text)[:2000]  # Increased from 1000 to 2000 for full content
-
-
-# ===== SCRAPER FUNCTIONS (required by ai_patch.py) =====
-def scrape_any_url(url: str) -> dict:
-    """Scrape any URL and extract article content.
-    
-    Returns dict with: title, summary, text, image, og_image, via (domain)
-    """
-    try:
-        r = requests.get(url, headers=HEADERS, timeout=15, allow_redirects=True)
-        r.encoding = 'utf-8'
-        soup = BeautifulSoup(r.text, 'lxml')
-        
-        # Remove scripts, styles, nav, footer
-        for tag in soup.find_all(['script', 'style', 'nav', 'footer', 'aside', 'form']):
-            tag.decompose()
-        
-        # Extract title
-        h1 = soup.find('h1')
-        ogt = soup.find('meta', property='og:title')
-        title = (h1.get_text(strip=True) if h1 else '') or (ogt.get('content', '') if ogt else url)
-        
-        # Extract OG image
-        ogi = soup.find('meta', property='og:image')
-        og_image = ogi.get('content', '') if ogi else ''
-        
-        # Extract article body
-        block = None
-        for sel in ['article', '.singular-content', '.detail-content', '.fck_detail', '.content-detail', '.knc-content', 'main', '.cms-body', '.article__body']:
-            el = soup.select_one(sel)
-            if el and len(el.find_all('p')) >= 2:
-                block = el
-                break
-        if not block:
-            block = soup.body or soup
-        
-        # Extract text from paragraphs
-        paragraphs = []
-        for el in block.find_all(['p', 'h2', 'h3'], recursive=True):
-            t = _clean_text(el.get_text(strip=True))
-            if t and len(t) > 40:
-                paragraphs.append(t)
-        
-        # Extract images
-        images = []
-        for el in block.find_all(['figure', 'img'], recursive=True):
-            im = el if el.name == 'img' else el.find('img')
-            if im:
-                src = im.get('data-src') or im.get('src') or im.get('data-original') or ''
-                if src and 'base64' not in src:
-                    if src.startswith('//'):
-                        src = 'https:' + src
-                    images.append(src)
-        
-        # Prefer OG image as main image
-        image = og_image or (images[0] if images else '')
-        
-        return {
-            'title': title,
-            'summary': paragraphs[0] if paragraphs else '',
-            'text': '\n'.join(paragraphs),
-            'image': image,
-            'og_image': og_image,
-            'via': _domain(url),
-            'images': images
-        }
-    except Exception as e:
-        return {'title': url, 'summary': '', 'text': '', 'image': '', 'og_image': '', 'via': _domain(url), 'error': str(e)}
-
-
-def web_context(topic: str, limit: int = 5) -> tuple:
-    """Get web context for a topic. Returns (context_text, sources_list)."""
-    sources = []
-    try:
-        # Try Google News RSS
-        rss_url = f"https://news.google.com/rss/search?q={quote_plus(topic)}&hl=vi&gl=VN&ceid=VN:vi"
-        r = requests.get(rss_url, headers=HEADERS, timeout=15)
-        r.encoding = 'utf-8'
-        soup = BeautifulSoup(r.text, 'xml')
-        for it in soup.find_all('item')[:limit]:
-            title = it.find('title').get_text(' ', strip=True) if it.find('title') else ''
-            link = it.find('link').get_text(strip=True) if it.find('link') else ''
-            if title and link:
-                sources.append({'title': title, 'url': link, 'via': _domain(link)})
-    except Exception:
-        pass
-    
-    context = f'Trên mạng có nhiều bài viết về "{topic}". Một số nguồn: ' + ', '.join([s.get('title', '') for s in sources[:3]])
-    return context, sources
-
-
-# ===== SHORT FRAME FUNCTION (required by ai_patch.py) =====
-def _make_short_frame(post, img_path, out_path):
-    """Create a short video frame from post and image.
-    
-    Called by ai_patch.py _make_short_frame_full when Image is available.
-    """
-    if Image is None:
-        # Create a minimal frame without PIL - just return success
-        # The caller should handle this case
-        return False
-    
-    W, H = 1080, 1920
-    bg = Image.new("RGB", (W, H), (14, 14, 14))
-    
-    try:
-        im = Image.open(img_path).convert("RGB")
-        target = (1080, 760)
-        im_ratio = im.width / max(1, im.height)
-        target_ratio = target[0] / target[1]
-        
-        if im_ratio > target_ratio:
-            new_h = target[1]
-            new_w = int(new_h * im_ratio)
-        else:
-            new_w = target[0]
-            new_h = int(new_w / im_ratio)
-        
-        im = im.resize((new_w, new_h))
-        left = (new_w - target[0]) // 2
-        top = (new_h - target[1]) // 2
-        im = im.crop((left, top, left + target[0], top + target[1]))
-        bg.paste(im, (0, 0))
-    except Exception:
-        pass
-    
-    draw = ImageDraw.Draw(bg)
-    
-    try:
-        font_title = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 54)
-        font_body = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 38)
-    except Exception:
-        font_title = font_body = None
-    
-    draw.rectangle((0, 720, W, H), fill=(14, 14, 14))
-    margin = 48
-    maxw = W - margin * 2
-    
-    y = 830
-    for ln in _wrap_text(draw, post.get("title", ""), font_title, maxw, 4):
-        draw.text((margin, y), ln, fill=(255, 255, 255), font=font_title)
-        y += 66
-    
-    y += 18
-    text = post.get("text", "")
-    text = re.sub(r"Nguồn tham khảo:.*", "", text, flags=re.S).strip()
-    body_lines = _wrap_text(draw, text, font_body, maxw, 14)
-    for ln in body_lines:
-        draw.text((margin, y), ln, fill=(220, 220, 220), font=font_body)
-        y += 50
-        if y > 1640:
-            break
-    
-    bg.save(out_path, quality=92)
-    return True
-
-
-def _wrap_text(draw, text, font, max_width, max_lines):
-    """Helper for wrapping text in frames."""
-    words = _clean_text(text).split()
-    lines, cur = [], ""
-    for w in words:
-        test = (cur + " " + w).strip()
-        try:
-            width = draw.textbbox((0, 0), test, font=font)[2]
-        except Exception:
-            width = len(test) * 20
-        if width <= max_width:
-            cur = test
-        else:
-            if cur:
-                lines.append(cur)
-            cur = w
-        if len(lines) >= max_lines:
-            break
-    if cur and len(lines) < max_lines:
-        lines.append(cur)
-    return lines

ai_patch.py

@@ -1,917 +0,0 @@
-import os
-import re
-import time
-import random
-import json
-import html as html_lib
-import subprocess
-import requests
-import hashlib
-import ai_ext as base
-from ai_ext import app
-from fastapi import Request
-from fastapi.responses import JSONResponse, HTMLResponse, FileResponse
-from bs4 import BeautifulSoup
-from urllib.parse import quote_plus
-
-try:
-    from PIL import Image, ImageDraw, ImageFont
-except Exception:
-    Image = ImageDraw = ImageFont = None
-
-
-def _clean(s):
-    s = html_lib.unescape(s or "")
-    s = re.sub(r"[ \t]+", " ", s)
-    s = re.sub(r"\n{3,}", "\n\n", s)
-    return s.strip()
-
-
-def _norm(s):
-    s = s.lower()
-    s = re.sub(r"[^\wÀ-ỹ\s]", " ", s)
-    s = re.sub(r"\s+", " ", s).strip()
-    return s
-
-
-def _similar(a, b):
-    ta = set(_norm(a).split())
-    tb = set(_norm(b).split())
-    if not ta or not tb:
-        return False
-    return len(ta & tb) / max(1, min(len(ta), len(tb))) >= 0.72
-
-
-def _dedupe_units(units, max_units=25):
-    """Deduplicate units - only skip exact matches to ensure all bullet points are read."""
-    out, seen = [], set()
-    for u in units:
-        u = _clean(re.sub(r"^[-•*\d\.\)\s]+", "", u))
-        if len(u) < 18:
-            continue
-        nu = _norm(u)
-        # Only skip exact matches, NOT similar content (to avoid skipping valid bullet points)
-        if nu in seen:
-            continue
-        seen.add(nu)
-        out.append(u)
-        if len(out) >= max_units:
-            break
-    return out
-
-
-def _postprocess_ai_text(text, max_units=20):
-    text = _clean(text)
-    if not text:
-        return text
-    drop_prefixes = (
-        "dưới đây", "sau đây", "bài viết", "tôi sẽ", "mình sẽ",
-        "tóm tắt bài", "tiêu đề:", "sapo:", "nội dung:", "kết luận:"
-    )
-    raw_lines = []
-    for line in re.split(r"\n+", text):
-        line = _clean(line)
-        if not line:
-            continue
-        low = line.lower().strip()
-        if any(low.startswith(p) and len(line) < 80 for p in drop_prefixes):
-            continue
-        raw_lines.append(line)
-    units = []
-    for line in raw_lines:
-        # KEEP FULL bullet point - don't truncate or split into segments
-        if len(line) >= 18:
-            units.append(_clean(re.sub(r"^[-•*\d\.\)\s]+", "", line)))
-    units = _dedupe_units(units, max_units=max_units)
-    if not units:
-        return text[:900]
-    title = ""
-    if raw_lines and len(raw_lines[0]) <= 90 and not raw_lines[0].startswith(("-", "•", "*")):
-        title = raw_lines[0]
-        units = [u for u in units if not _similar(u, title)]
-    body = "\n".join("• " + u for u in units[:max_units])
-    return (title + "\n\n" + body).strip() if title else body
-
-
-def _fallback_summary_from_prompt(prompt, max_units=6):
-    text = prompt or ""
-    for marker in ["Nội dung nguồn:", "Nội dung bài:", "Nội dung gốc:", "Nội dung:", "Nguồn/bối cảnh internet:"]:
-        if marker in text:
-            text = text.split(marker, 1)[1]
-            break
-    text = re.sub(r"https?://\S+", "", text)
-    text = re.sub(r"\s+", " ", text).strip()
-    sentences = re.split(r"(?<=[\.\!\?])\s+(?=[A-ZÀ-Ỹ0-9])", text)
-    candidates = []
-    for s in sentences:
-        s = _clean(s)
-        if 45 <= len(s) <= 260:
-            candidates.append(s)
-    units = _dedupe_units(candidates, max_units=max_units)
-    if units:
-        return "\n".join("• " + u for u in units)
-    if text:
-        return "• " + text[:700].rsplit(" ", 1)[0]
-    return "• Không có đủ nội dung nguồn để tóm tắt."
-
-
-def _source_line(sources):
-    names = []
-    for s in (sources or [])[:5]:
-        via = s.get("via") or base._domain(s.get("url", "")) or s.get("title", "")
-        if via and via not in names:
-            names.append(via)
-    return "Nguồn tham khảo: " + ", ".join(names[:5]) if names else "Nguồn tham khảo: tổng hợp internet"
-
-
-def _make_summary_prompt(title, raw, source_hint=""):
-    return f"""Bạn là biên tập viên tóm tắt tin tức tiếng Việt.
-
-NHIỆM VỤ BẮT BUỘC:
-- Chỉ TÓM TẮT nội dung chính, KHÔNG viết lại toàn bộ bài.
-- Không lặp lại cùng một ý, cùng một câu, cùng một chi tiết.
-- Không thêm thông tin ngoài nguồn.
-- Tối đa 5 gạch đầu dòng, mỗi gạch đầu dòng 1 câu ngắn.
-- Nếu bài có số liệu/nhân vật/thời điểm quan trọng thì giữ lại.
-- Không viết phần mở bài dài, không viết văn kể lại.
-
-Tiêu đề nguồn: {title}
-Nguồn: {source_hint}
-
-Nội dung nguồn:
-{raw[:14000]}
-"""
-
-
-def _direct_news_rss(topic, limit=10):
-    out = []
-    try:
-        url = "https://news.google.com/rss/search?q=" + quote_plus(topic) + "&hl=vi&gl=VN&ceid=VN:vi"
-        r = requests.get(url, headers=base.HEADERS, timeout=15)
-        r.encoding = "utf-8"
-        soup = BeautifulSoup(r.text, "xml")
-        for it in soup.find_all("item")[:limit]:
-            title = it.find("title").get_text(" ", strip=True) if it.find("title") else ""
-            link = it.find("link").get_text(strip=True) if it.find("link") else ""
-            src = it.find("source").get_text(" ", strip=True) if it.find("source") else base._domain(link)
-            if title and link:
-                out.append({"title": title, "url": link, "via": src, "excerpt": title})
-    except Exception:
-        pass
-    return out
-
-
-def _topic_source_articles(topic, limit=5):
-    """Return actual scraped article bodies for a topic. Each source becomes one Wall AI post."""
-    try:
-        _ctx, sources = base.web_context(topic, limit=limit)
-    except Exception:
-        sources = []
-    if not sources:
-        sources = _direct_news_rss(topic, limit=10)
-    out, seen = [], set()
-    for s in (sources or [])[:limit * 3]:
-        url = s.get("url") or ""
-        if not url.startswith("http") or url in seen:
-            continue
-        seen.add(url)
-        try:
-            page = base.scrape_any_url(url)
-            raw = (page.get("summary", "") + "\n" + page.get("text", "")).strip()
-            if len(raw) < 180:
-                continue
-            title = page.get("title") or s.get("title") or url
-            via = page.get("via") or s.get("via") or base._domain(url)
-            out.append({
-                "title": title,
-                "url": url,
-                "raw": raw,
-                "image": page.get("image") or "",
-                "via": via,
-                "source": {"title": title, "url": url, "excerpt": raw[:700], "via": via}
-            })
-            if len(out) >= limit:
-                break
-        except Exception:
-            continue
-    if not out:
-        for s in (sources or _direct_news_rss(topic, 6))[:limit]:
-            title = s.get("title") or topic
-            excerpt = s.get("excerpt") or s.get("description") or s.get("content") or title
-            url = s.get("url", "")
-            via = s.get("via") or base._domain(url)
-            out.append({
-                "title": title,
-                "url": url,
-                "raw": excerpt,
-                "image": base.pollinations_image_url(title),
-                "via": via,
-                "source": {"title": title, "url": url, "excerpt": excerpt[:700], "via": via}
-            })
-    return out[:limit]
-
-
-async def qwen_generate_resilient(prompt: str, image_url=None, max_tokens: int = 1200):
-    errors = []
-    token = base._hf_token()
-    try:
-        original = getattr(base, "_original_qwen_generate", None)
-        if original:
-            txt = await original(prompt, image_url=image_url, max_tokens=max_tokens)
-            if txt:
-                base.LAST_QWEN_ERROR = ""
-                return txt
-            if getattr(base, "LAST_QWEN_ERROR", ""):
-                errors.append("sdk: " + str(base.LAST_QWEN_ERROR)[:260])
-    except Exception as e:
-        errors.append(f"sdk: {type(e).__name__}: {str(e)[:260]}")
-    if token:
-        models = []
-        for m in [
-            os.getenv("QWEN_VL_MODEL", ""),
-            "Qwen/Qwen2.5-VL-7B-Instruct",
-            "Qwen/Qwen2.5-VL-3B-Instruct",
-            "Qwen/Qwen2.5-7B-Instruct",
-            "Qwen/Qwen2.5-3B-Instruct",
-            "Qwen/Qwen2.5-1.5B-Instruct",
-        ]:
-            if m and m not in models:
-                models.append(m)
-        headers = {"Authorization": "Bearer " + token, "Content-Type": "application/json"}
-        for model in models:
-            try:
-                is_vl = "VL" in model and bool(image_url)
-                user_content = ([{"type": "image_url", "image_url": {"url": image_url}}, {"type": "text", "text": prompt}] if is_vl else prompt)
-                payload = {
-                    "model": model,
-                    "messages": [
-                        {"role": "system", "content": "Bạn là biên tập viên AI tiếng Việt. Chỉ tóm tắt súc tích nội dung nguồn, không viết lại toàn bài, không lặp ý, không bịa chi tiết."},
-                        {"role": "user", "content": user_content},
-                    ],
-                    "max_tokens": min(int(max_tokens or 900), 1400),
-                    "temperature": 0.35,
-                    "top_p": 0.85,
-                }
-                r = requests.post("https://router.huggingface.co/v1/chat/completions", headers=headers, json=payload, timeout=95)
-                if r.status_code >= 300:
-                    errors.append(f"{model}: HTTP {r.status_code} {r.text[:180]}")
-                    continue
-                j = r.json()
-                txt = (j.get("choices", [{}])[0].get("message", {}).get("content") or "").strip()
-                if txt:
-                    base.LAST_QWEN_ERROR = ""
-                    return txt
-                errors.append(f"{model}: empty response")
-            except Exception as e:
-                errors.append(f"{model}: {type(e).__name__}: {str(e)[:220]}")
-    else:
-        errors.append("missing HF_TOKEN")
-    base.LAST_QWEN_ERROR = " | ".join(errors[-6:]) or "Qwen unavailable; used extractive fallback"
-    print("[qwen resilient fallback]", base.LAST_QWEN_ERROR)
-    return _fallback_summary_from_prompt(prompt, max_units=12)
-
-
-if not hasattr(base, "_original_qwen_generate"):
-    base._original_qwen_generate = base.qwen_generate
-base.qwen_generate = qwen_generate_resilient
-
-
-@app.get('/api/wall')
-def compat_wall():
-    return JSONResponse({'posts': base._load_ai_wall()[:80]})
-
-
-_PATCHED_PATHS = {
-    ('/api/topic_post', 'POST'),
-    ('/api/url_wall', 'POST'),
-    ('/api/rewrite_share', 'POST'),
-    ('/api/ai/short/{post_id}', 'POST'),
-}
-app.router.routes = [
-    r for r in app.router.routes
-    if not any(getattr(r, 'path', None) == p and m in getattr(r, 'methods', set()) for p, m in _PATCHED_PATHS)
-]
-
-
-@app.post('/api/topic_post')
-async def compat_topic_post(request: Request):
-    body = await request.json()
-    topic = base._clean_text(body.get('topic', ''))
-    if not topic:
-        return JSONResponse({'error': 'missing topic'}, status_code=400)
-    articles = _topic_source_articles(topic, limit=4)
-    if not articles:
-        return JSONResponse({'error': 'Không lấy được bài viết nguồn cho chủ đề này.'}, status_code=422)
-    new_posts = []
-    posts = base._load_ai_wall()
-    for art in articles:
-        prompt = f"""Tóm tắt RIÊNG bài viết nguồn sau để đăng Tường AI.
-
-Chủ đề lọc: {topic}
-Tiêu đề bài nguồn: {art['title']}
-Nguồn: {art['via']}
-
-Yêu cầu bắt buộc:
-- Tóm tắt nội dung trong BÀI VIẾT này, không chỉ tiêu đề.
-- Không trộn với bài khác.
-- Không viết lại toàn bộ bài.
-- Không lặp ý.
-- 4-6 gạch đầu dòng, mỗi dòng 1 câu rõ ràng.
-- Giữ số liệu/nhân vật/thời điểm quan trọng nếu có.
-
-Nội dung bài:
-{art['raw'][:14000]}"""
-        text = await base.qwen_generate(prompt, image_url=art.get('image') or None, max_tokens=1500)
-        text = _postprocess_ai_text(text, max_units=20)
-        src = [art['source']]
-        if 'Nguồn tham khảo:' not in text:
-            text += "\n\n" + _source_line(src)
-        post = base.make_post(art['title'], text, art.get('image') or base.pollinations_image_url(art['title']), art.get('url') or '', 'topic_article', sources=src)
-        
-        # Generate slides for this post so they persist after page reload
-        try:
-            page_data = _scrape_article_images(art.get('url', ''))
-            if page_data and page_data.get('paragraphs'):
-                key_points = _extract_key_points_for_slides(page_data['paragraphs'], max_points=12)
-                if key_points:
-                    relevant_imgs = page_data.get('images', [])
-                    if not relevant_imgs and page_data.get('og_img'):
-                        relevant_imgs = [page_data['og_img']]
-                    slides = []
-                    for i, point in enumerate(key_points):
-                        img = relevant_imgs[i] if i < len(relevant_imgs) else (relevant_imgs[-1] if relevant_imgs else '')
-                        slides.append({'text': point, 'image': img, 'index': i + 1})
-                    post['slides'] = slides
-        except Exception:
-            pass
-        
-        new_posts.append(post)
-    posts = new_posts + posts
-    base._save_ai_wall(posts)
-    return JSONResponse({'post': new_posts[0], 'posts': new_posts, 'count': len(new_posts)})
-
-
-@app.post('/api/url_wall')
-async def compat_url_wall(request: Request):
-    body = await request.json()
-    url = base._clean_text(body.get('url', ''))
-    if not url.startswith('http'):
-        return JSONResponse({'error': 'missing url'}, status_code=400)
-    try:
-        data = base.scrape_any_url(url)
-    except Exception as e:
-        return JSONResponse({'error': 'Không scrape được URL: ' + str(e)[:180]}, status_code=422)
-    raw = (data.get('summary', '') + '\n' + data.get('text', '')).strip()
-    if len(raw) < 120:
-        return JSONResponse({'error': 'URL không có đủ nội dung để tóm tắt'}, status_code=422)
-    prompt = _make_summary_prompt(data.get('title', ''), raw, data.get('via', '') or base._domain(url))
-    text = await base.qwen_generate(prompt, image_url=data.get('image') or None, max_tokens=1500)
-    text = _postprocess_ai_text(text, max_units=20)
-    src = [{'title': data.get('title'), 'url': url, 'excerpt': raw[:500], 'via': data.get('via') or base._domain(url)}]
-    if 'Nguồn tham khảo:' not in text:
-        text += "\n\n" + _source_line(src)
-    post = base.make_post(data.get('title') or 'Bài viết', text, data.get('image') or '', url, 'url', sources=src)
-    
-    # Generate slides so they persist after page reload
-    slides = []
-    try:
-        page_data = _scrape_article_images(url)
-        if page_data and page_data.get('paragraphs'):
-            key_points = _extract_key_points_for_slides(page_data['paragraphs'], max_points=12)
-            if key_points:
-                relevant_imgs = page_data.get('images', [])
-                if not relevant_imgs and page_data.get('og_img'):
-                    relevant_imgs = [page_data['og_img']]
-                for i, point in enumerate(key_points):
-                    img = relevant_imgs[i] if i < len(relevant_imgs) else (relevant_imgs[-1] if relevant_imgs else '')
-                    slides.append({'text': point, 'image': img, 'index': i + 1})
-    except Exception:
-        pass
-    post['slides'] = slides
-    
-    posts = base._load_ai_wall(); posts.insert(0, post); base._save_ai_wall(posts)
-    return JSONResponse({'post': post, 'slides': slides})
-
-
-def _is_relevant_image(img_url, title, text):
-    """Check if an image is relevant to the article content."""
-    if not img_url:
-        return False
-    skip_patterns = ['pixel', 'analytics', 'tracking', '1x1.gif', 'spacer.gif',
-                     'logo', 'icon', 'avatar', 'emoji', 'smiley', 'sprite',
-                     'advertisement', 'ad-banner', 'sponsored', 'banner-ads']
-    img_lower = img_url.lower()
-    for p in skip_patterns:
-        if p in img_lower:
-            return False
-    if not any(img_lower.endswith(ext) for ext in ['.jpg', '.jpeg', '.png', '.webp', '.gif']):
-        return False
-    return True
-
-
-def _filter_relevant_images(images, title, text, max_images=8):
-    """Filter and rank images by relevance to article content."""
-    if not images:
-        return []
-    seen = set()
-    relevant = []
-    for img in images:
-        if img in seen:
-            continue
-        seen.add(img)
-        if _is_relevant_image(img, title, text):
-            relevant.append(img)
-    return relevant[:max_images]
-
-
-def _extract_key_points_for_slides(paragraphs, max_points=12):
-    """Extract key points from paragraphs for slides - extracts ALL sentences, not just first one."""
-    points = []
-    for p in paragraphs:
-        if len(points) >= max_points:
-            break
-        p = _clean(p)
-        if not p:
-            continue
-        # Split paragraph into sentences using Vietnamese + English punctuation - GET ALL SENTENCES
-        sentences = re.split(r'(?<=[.!?])\s+(?=[A-ZÀ-Ỹ0-9])', p)
-        sentences = [s.strip() for s in sentences if s.strip()]
-        
-        for sentence in sentences:
-            if len(points) >= max_points:
-                break
-            sentence = _clean(sentence)
-            if len(sentence) < 30:
-                continue
-            if any(sentence[:60] in existing for existing in points):
-                continue
-            if not sentence.endswith(('.', '!', '?')):
-                sentence = sentence + '.'
-            points.append(sentence)
-    return points
-
-
-def _scrape_article_images(url):
-    """Scrape article page and return only relevant images."""
-    try:
-        headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
-                   "Accept-Language": "vi-VN,vi;q=0.9,en;q=0.8"}
-        r = requests.get(url, headers=headers, timeout=15, allow_redirects=True)
-        r.encoding = 'utf-8'
-        soup = BeautifulSoup(r.text, 'lxml')
-        for tag in soup.find_all(['script', 'style', 'nav', 'footer', 'aside', 'form']):
-            tag.decompose()
-        h1 = soup.find('h1')
-        ogt = soup.find('meta', property='og:title')
-        title = (h1.get_text(strip=True) if h1 else '') or (ogt.get('content', '') if ogt else '')
-        ogi = soup.find('meta', property='og:image')
-        og_img = ogi.get('content', '') if ogi else ''
-        if og_img and og_img.startswith('//'):
-            og_img = 'https:' + og_img
-        block = None
-        for sel in ['article', '.singular-content', '.detail-content', '.fck_detail', '.content-detail', '.knc-content', 'main', '.cms-body', '.article__body']:
-            el = soup.select_one(sel)
-            if el and len(el.find_all('p')) >= 2:
-                block = el
-                break
-        if not block:
-            block = soup.body or soup
-        paragraphs = []
-        all_images = []
-        seen_imgs = set()
-        if og_img and og_img not in seen_imgs:
-            all_images.append(og_img)
-            seen_imgs.add(og_img)
-        for el in block.find_all(['p', 'h2', 'h3', 'figure', 'img'], recursive=True):
-            if el.name == 'p':
-                t = _clean(el.get_text(strip=True))
-                if t and len(t) > 40:
-                    paragraphs.append(t)
-            elif el.name in ('figure', 'img'):
-                im = el if el.name == 'img' else el.find('img')
-                if im:
-                    src = im.get('data-src') or im.get('src') or im.get('data-original') or ''
-                    if src and 'base64' not in src:
-                        if src.startswith('//'):
-                            src = 'https:' + src
-                        if src not in seen_imgs:
-                            all_images.append(src)
-                            seen_imgs.add(src)
-        relevant_images = _filter_relevant_images(all_images, title, ' '.join(paragraphs[:5]))
-        return {'title': _clean(title), 'paragraphs': paragraphs, 'images': relevant_images, 'og_img': og_img}
-    except Exception:
-        return None
-
-
-@app.post('/api/rewrite_share')
-async def compat_rewrite_share(request: Request):
-    body = await request.json()
-    url = base._clean_text(body.get('url', ''))
-    if not url.startswith('http'):
-        return JSONResponse({'error': 'missing url'}, status_code=400)
-    try:
-        data = base.scrape_any_url(url)
-    except Exception as e:
-        return JSONResponse({'error': 'Không đọc được bài viết: ' + str(e)[:180]}, status_code=422)
-    raw = (data.get('summary', '') + '\n' + data.get('text', '')).strip()
-    if len(raw) < 120:
-        return JSONResponse({'error': 'Bài viết không đủ nội dung để tóm tắt'}, status_code=422)
-    prompt = _make_summary_prompt(data.get('title', ''), raw, data.get('via', '') or base._domain(url))
-    text = await base.qwen_generate(prompt, image_url=data.get('image') or None, max_tokens=1500)
-    text = _postprocess_ai_text(text, max_units=20)
-    src = [{'title': data.get('title'), 'url': url, 'excerpt': raw[:500], 'via': data.get('via') or base._domain(url)}]
-    if 'Nguồn tham khảo:' not in text:
-        text += "\n\n" + _source_line(src)
-    post = base.make_post(data.get('title') or 'Bài viết', text, data.get('image') or '', url, 'summary', sources=src)
-
-    # Generate slides with relevant images only
-    slides = []
-    page_data = _scrape_article_images(url)
-    if page_data and page_data.get('paragraphs'):
-        key_points = _extract_key_points_for_slides(page_data['paragraphs'], max_points=12)
-        if key_points:
-            relevant_imgs = page_data.get('images', [])
-            if not relevant_imgs and page_data.get('og_img'):
-                relevant_imgs = [page_data['og_img']]
-            for i, point in enumerate(key_points):
-                img = relevant_imgs[i] if i < len(relevant_imgs) else (relevant_imgs[-1] if relevant_imgs else '')
-                slides.append({'text': point, 'image': img, 'index': i + 1})
-
-    # FIX: Save slides into post so they persist after page reload
-    post['slides'] = slides
-    posts = base._load_ai_wall(); posts.insert(0, post); base._save_ai_wall(posts)
-
-    return JSONResponse({'post': post, 'slides': slides})
-
-
-def _emotion_script(text, emotion):
-    """Prepend emotion-appropriate prefix to text based on emotion type.
-    
-    NOTE: Prefix is NOT added to avoid cluttering Short AI speech.
-    The emotion is still used for voice selection but content is read cleanly.
-    """
-    text = _clean(text)
-    # REMOVED: No prefix added to keep content clean and natural
-    return text
-
-
-def _tts_script_smart(post, emotion):
-    raw = base._short_script(post) if hasattr(base, '_short_script') else _clean(post.get('text', '') or post.get('title', ''))
-    raw = re.sub(r"^[•\-\*]\s*", "", raw, flags=re.M)
-    raw = re.sub(r"\s*\n\s*", ". ", raw)
-    raw = re.sub(r"([\.\!\?])\s*", r"\1\n", raw)
-    raw = re.sub(r"\n{2,}", "\n", raw).strip()
-    # REMOVED: _emotion_script call - read content cleanly without prefix
-    # INCREASED to 3000 to read full content of all bullet points
-    if len(raw) > 3000:
-        raw = raw[:3000]
-        cut = max(raw.rfind("."), raw.rfind("!"), raw.rfind("?"))
-        if cut > 700:
-            raw = raw[:cut + 1]
-    return raw
-
-
-def _split_subtitle_sentences(script):
-    parts = []
-    for line in script.splitlines():
-        line = _clean(line)
-        if not line:
-            continue
-        for s in re.split(r"(?<=[\.\!\?])\s+", line):
-            s = _clean(s)
-            if 8 <= len(s) <= 140:
-                parts.append(s)
-    return parts[:12]
-
-
-def _srt_time(sec):
-    ms = int((sec - int(sec)) * 1000)
-    sec = int(sec)
-    h = sec // 3600
-    m = (sec % 3600) // 60
-    s = sec % 60
-    return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
-
-
-def _write_srt(script, path, total_duration=30):
-    subs = _split_subtitle_sentences(script)
-    if not subs:
-        subs = [script[:120]]
-    dur = max(2.2, min(5.0, total_duration / max(1, len(subs))))
-    cur = 0.3
-    with open(path, 'w', encoding='utf-8') as f:
-        for i, s in enumerate(subs, 1):
-            start = cur
-            end = cur + dur
-            cur = end + 0.15
-            f.write(f"{i}\n{_srt_time(start)} --> {_srt_time(end)}\n{s}\n\n")
-
-
-def _wrap_text_px(draw, text, font, max_width, max_lines):
-    words = _clean(text).split()
-    lines, cur = [], ""
-    for w in words:
-        test = (cur + " " + w).strip()
-        try:
-            width = draw.textbbox((0, 0), test, font=font)[2]
-        except Exception:
-            width = len(test) * 20
-        if width <= max_width:
-            cur = test
-        else:
-            if cur:
-                lines.append(cur)
-            cur = w
-        if len(lines) >= max_lines:
-            break
-    if cur and len(lines) < max_lines:
-        lines.append(cur)
-    return lines
-
-
-def _make_short_frame_full(post, img_path, out_path):
-    if Image is None:
-        return base._make_short_frame(post, img_path, out_path)
-    W, H = 1080, 1920
-    bg = Image.new("RGB", (W, H), (14, 14, 14))
-    try:
-        im = Image.open(img_path).convert("RGB")
-        target = (1080, 760)
-        im_ratio = im.width / im.height
-        target_ratio = target[0] / target[1]
-        if im_ratio > target_ratio:
-            new_h = target[1]
-            new_w = int(new_h * im_ratio)
-        else:
-            new_w = target[0]
-            new_h = int(new_w / im_ratio)
-        im = im.resize((new_w, new_h))
-        left = (new_w - target[0]) // 2
-        top = (new_h - target[1]) // 2
-        im = im.crop((left, top, left + target[0], top + target[1]))
-        bg.paste(im, (0, 0))
-    except Exception:
-        pass
-    draw = ImageDraw.Draw(bg)
-    try:
-        font_title = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 54)
-        font_body = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 38)
-        font_label = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 30)
-    except Exception:
-        font_title = font_body = font_label = None
-    draw.rectangle((0, 720, W, H), fill=(14, 14, 14))
-    margin = 48
-    maxw = W - margin * 2
-    draw.text((margin, 770), "VNEWS · Tường AI", fill=(92, 184, 122), font=font_label)
-    y = 830
-    for ln in _wrap_text_px(draw, post.get("title", ""), font_title, maxw, 4):
-        draw.text((margin, y), ln, fill=(255, 255, 255), font=font_title)
-        y += 66
-    y += 18
-    text = post.get("text", "")
-    text = re.sub(r"Nguồn tham khảo:.*", "", text, flags=re.S).strip()
-    body_lines = _wrap_text_px(draw, text, font_body, maxw, 14)
-    for ln in body_lines:
-        draw.text((margin, y), ln, fill=(220, 220, 220), font=font_body)
-        y += 50
-        if y > 1640:
-            break
-    bg.save(out_path, quality=92)
-
-
-
-
-def _summary_segments_from_post(post, max_segments=25):
-    raw = _clean(post.get('text') or post.get('title') or '')
-    raw = re.sub(r'^Bản tin AI viết lại:\s*', '', raw, flags=re.I)
-    raw = re.sub(r'Nguồn tham khảo:.*$', '', raw, flags=re.I|re.S).strip()
-    lines=[]
-    for ln in raw.splitlines():
-        ln=_clean(re.sub(r'^[•\-\*\d\.\)\s]+','',ln))
-        if not ln: continue
-        low=ln.lower()
-        if low.startswith(('điểm chính','tiêu đề','sapo','nguồn tham khảo')): continue
-        if len(ln)>=18: lines.append(ln)
-    if len(lines)<3:
-        lines=[]
-        for s in re.split(r'(?<=[\.\!\?])\s+', raw):
-            s=_clean(s)
-            if len(s)>=25: lines.append(s)
-    segs=_dedupe_units(lines, max_units=max_segments)
-    return segs[:max_segments] if segs else [post.get('title','Bản tin VNEWS')]
-
-
-def _make_scene_frame(post, segment, idx, total, img_path, out_path, emotion='neutral'):
-    if Image is None:
-        return _make_short_frame_full(post, img_path, out_path)
-    W,H=1080,1920
-    bg=Image.new('RGB',(W,H),(10,10,10))
-    try:
-        im=Image.open(img_path).convert('RGB')
-        ratio=im.width/max(1,im.height); target=W/H
-        if ratio>target:
-            nh=H; nw=int(nh*ratio)
-        else:
-            nw=W; nh=int(nw/ratio)
-        cover=im.resize((nw,nh)); left=(nw-W)//2; top=(nh-H)//2
-        cover=cover.crop((left,top,left+W,top+H))
-        bg.paste(cover,(0,0))
-        bg=Image.blend(bg, Image.new('RGB',(W,H),(0,0,0)), 0.50)
-        hero_h=720; target=W/hero_h
-        if ratio>target:
-            nh=hero_h; nw=int(nh*ratio)
-        else:
-            nw=W; nh=int(nw/ratio)
-        hero=im.resize((nw,nh)); left=(nw-W)//2; top=(nh-hero_h)//2
-        hero=hero.crop((left,top,left+W,top+hero_h))
-        bg.paste(hero,(0,0))
-    except Exception:
-        pass
-    draw=ImageDraw.Draw(bg)
-    try:
-        font_brand=ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf',34)
-        font_small=ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf',28)
-        font_seg=ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf',58)
-        font_title=ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf',34)
-    except Exception:
-        font_brand=font_small=font_seg=font_title=None
-    draw.rectangle((0,680,W,H), fill=(12,12,12))
-    dot_x=48; dot_y=742
-    for i in range(total):
-        fill=(92,184,122) if i==idx else (70,70,70)
-        draw.rounded_rectangle((dot_x+i*38,dot_y,dot_x+i*38+24,dot_y+10), radius=5, fill=fill)
-    draw.text((48,780),'VNEWS AI SHORT',fill=(110,231,143),font=font_brand)
-    draw.rounded_rectangle((48,834,260,880), radius=20, fill=(28,70,45))
-    draw.text((66,842),f'Đoạn {idx+1}/{total}',fill=(235,235,235),font=font_small)
-    y=940; maxw=W-96
-    # INCREASED from 12 to 18 for full content display - each key point can span multiple lines
-    for ln in _wrap_text_px(draw, segment, font_seg, maxw, 18):
-        draw.text((48,y),ln,fill=(255,255,255),font=font_seg)
-        y+=74
-        if y>1500: break
-    y2=1640
-    draw.line((48,y2-22,W-48,y2-22),fill=(70,70,70),width=2)
-    for ln in _wrap_text_px(draw, post.get('title',''), font_title, maxw, 3):
-        draw.text((48,y2),ln,fill=(220,220,220),font=font_title)
-        y2+=46
-    bg.save(out_path, quality=92)
-
-
-def _estimate_audio_duration(path, fallback=15.0):
-    """Estimate audio duration with 15s minimum per segment for complete bullet reading."""
-    try:
-        pr=subprocess.run(['ffprobe','-v','error','-show_entries','format=duration','-of','default=noprint_wrappers=1:no_key=1',path], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=20)
-        return max(12.0, float((pr.stdout or b'').decode().strip() or fallback))
-    except Exception:
-        return fallback
-
-
-@app.post('/api/ai/short/{post_id}')
-async def patched_ai_short(post_id: str, request: Request):
-    try:
-        body = await request.json()
-    except Exception:
-        body = {}
-    voice = str(body.get('voice', 'nu')).strip().lower()
-    emotion = str(body.get('emotion', 'neutral')).strip().lower()
-    speed = float(body.get('speed', 1.0) or 1.0)
-    speed = max(0.85, min(1.35, speed))
-
-    posts = base._load_ai_wall()
-    post = next((p for p in posts if str(p.get('id')) == str(post_id)), None)
-    if not post:
-        return JSONResponse({'error': 'post not found'}, status_code=404)
-
-    segments = _summary_segments_from_post(post, max_segments=25)
-    seg_hash = hashlib.md5(('|'.join(segments)+voice+emotion+str(speed)).encode('utf-8')).hexdigest()[:8]
-    os.makedirs(base.SHORTS_DIR, exist_ok=True)
-    suffix = f"_{voice}_{emotion}_{str(speed).replace('.', 'p')}_{seg_hash}_scenes_nosub"
-    out_mp4 = os.path.join(base.SHORTS_DIR, base._safe_name(post_id + suffix) + '.mp4')
-    if os.path.exists(out_mp4):
-        post['video'] = '/api/ai/short-file/' + post_id + suffix
-        post['short_voice'] = voice
-        post['short_emotion'] = emotion
-        post['short_speed'] = speed
-        post['short_segments'] = segments
-        post['short_subtitles'] = False
-        base._save_ai_wall(posts)
-        return JSONResponse({'video': post['video'], 'voice': voice, 'emotion': emotion, 'speed': speed, 'subtitles': False, 'segments': segments})
-    if base.gTTS is None:
-        return JSONResponse({'error': 'gTTS chưa sẵn sàng'}, status_code=503)
-
-    work = os.path.join(base.SHORTS_DIR, base._safe_name(post_id + suffix))
-    os.makedirs(work, exist_ok=True)
-    img = os.path.join(work, 'image.jpg')
-    try:
-        base._download_image(post.get('img'), post.get('title', 'AI news'), img)
-        edge_voice = {
-            # Vietnamese
-            'vi-vn-hoaimyneural': 'vi-VN-HoaiMyNeural',
-            'vi-vn-namminhneural': 'vi-VN-NamMinhNeural',
-            'hoaimy': 'vi-VN-HoaiMyNeural',
-            'namminh': 'vi-VN-NamMinhNeural',
-            'nam': 'vi-VN-NamMinhNeural',
-            'male': 'vi-VN-NamMinhNeural',
-            'nu': 'vi-VN-HoaiMyNeural',
-            'female': 'vi-VN-HoaiMyNeural',
-            'mien-nam': 'vi-VN-HoaiMyNeural',
-            # English - Multilingual
-            'en-us-andrewmultilingualneural': 'en-US-AndrewMultilingualNeural',
-            'en-au-williammultilingualneural': 'en-AU-WilliamMultilingualNeural',
-            'andrew': 'en-US-AndrewMultilingualNeural',
-            'en_andrew': 'en-US-AndrewMultilingualNeural',
-            'jenny': 'en-US-AndrewMultilingualNeural',
-            'en_jenny': 'en-US-AndrewMultilingualNeural',
-            # Portuguese - Multilingual (ONLY Thalita)
-            'pt-br-thalitamultilingualneural': 'pt-BR-ThalitaMultilingualNeural',
-            'thalita': 'pt-BR-ThalitaMultilingualNeural',
-            'pt_thalita': 'pt-BR-ThalitaMultilingualNeural',
-            'pt_br_thalita': 'pt-BR-ThalitaMultilingualNeural',
-            'pt': 'pt-BR-ThalitaMultilingualNeural',
-            'pt_francisco': 'pt-BR-ThalitaMultilingualNeural',
-            # French - Multilingual
-            'fr-fr-viviennemultilingualneural': 'fr-FR-VivienneMultilingualNeural',
-            'fr-fr-remymultilingualneural': 'fr-FR-RemyMultilingualNeural',
-            'denise': 'fr-FR-VivienneMultilingualNeural',
-            'fr': 'fr-FR-VivienneMultilingualNeural',
-            'fr_denise': 'fr-FR-VivienneMultilingualNeural',
-            # German - Multilingual
-            'de-de-seraphinamultilingualneural': 'de-DE-SeraphinaMultilingualNeural',
-            'de-de-florianmultilingualneural': 'de-DE-FlorianMultilingualNeural',
-            'katja': 'de-DE-SeraphinaMultilingualNeural',
-            'de': 'de-DE-SeraphinaMultilingualNeural',
-            'de_katja': 'de-DE-SeraphinaMultilingualNeural',
-            # Korean - Multilingual (Hyunsu, NOT SunHee)
-            'ko-kr-hyusumultilingualneural': 'ko-KR-HyunsuMultilingualNeural',
-            'ko-kr-hyunsuneural': 'ko-KR-HyunsuMultilingualNeural',
-            'sunhee': 'ko-KR-HyunsuMultilingualNeural',
-            'ko': 'ko-KR-HyunsuMultilingualNeural',
-            'ko_sunhee': 'ko-KR-HyunsuMultilingualNeural',
-            # Italian - Multilingual
-            'it-it-giuseppemultilingualneural': 'it-IT-GiuseppeMultilingualNeural',
-            # Spanish (keep for backward compat)
-            'ela': 'en-US-AndrewMultilingualNeural',
-            'es_ela': 'en-US-AndrewMultilingualNeural',
-            'es': 'en-US-AndrewMultilingualNeural',
-            'es_carlos': 'en-US-AndrewMultilingualNeural',
-            # Japanese (keep for backward compat)
-            'nanami': 'en-US-AndrewMultilingualNeural',
-            'ja': 'en-US-AndrewMultilingualNeural',
-            'ja_nanami': 'en-US-AndrewMultilingualNeural',
-            # Chinese (keep for backward compat)
-            'xiaochen': 'en-US-AndrewMultilingualNeural',
-            'zh': 'en-US-AndrewMultilingualNeural',
-            'zh_xiaochen': 'en-US-AndrewMultilingualNeural',
-        }.get(voice, 'vi-VN-HoaiMyNeural')
-        part_files=[]
-        for idx, seg in enumerate(segments):
-            frame=os.path.join(work,f'frame_{idx:02d}.jpg')
-            aud=os.path.join(work,f'voice_{idx:02d}.mp3')
-            aud_fast=os.path.join(work,f'voice_{idx:02d}_fast.mp3')
-            part=os.path.join(work,f'part_{idx:02d}.mp4')
-            _make_scene_frame(post, seg, idx, len(segments), img, frame, emotion=emotion)
-            spoken=_emotion_script(seg, emotion)
-            try:
-                subprocess.run(['python','-m','edge_tts','--voice',edge_voice,'--text',spoken,'--write-media',aud], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=120)
-            except Exception:
-                tld='com.vn' if voice in ('nu','female','mien-nam','hoaimy') else 'com'
-                try:
-                    base.gTTS(spoken, lang='vi', tld=tld, slow=False).save(aud)
-                except TypeError:
-                    base.gTTS(spoken, lang='vi', slow=False).save(aud)
-            subprocess.run(['ffmpeg','-y','-i',aud,'-filter:a',f'atempo={speed}','-vn',aud_fast], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=90)
-            dur=_estimate_audio_duration(aud_fast, fallback=15.0)+0.35
-            subprocess.run(['ffmpeg','-y','-loop','1','-t',str(dur),'-i',frame,'-i',aud_fast,'-shortest','-c:v','libx264','-tune','stillimage','-pix_fmt','yuv420p','-c:a','aac','-b:a','128k',part], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=150)
-            part_files.append(part)
-        concat=os.path.join(work,'concat.txt')
-        with open(concat,'w',encoding='utf-8') as f:
-            for p in part_files:
-                f.write("file '" + p.replace("'", "'\\''") + "'\n")
-        subprocess.run(['ffmpeg','-y','-f','concat','-safe','0','-i',concat,'-c','copy',out_mp4], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=180)
-        post['video'] = '/api/ai/short-file/' + post_id + suffix
-        post['short_voice'] = voice
-        post['short_emotion'] = emotion
-        post['short_speed'] = speed
-        post['short_segments'] = segments
-        post['short_subtitles'] = False
-        base._save_ai_wall(posts)
-        return JSONResponse({'video': post['video'], 'voice': voice, 'emotion': emotion, 'speed': speed, 'subtitles': False, 'segments': segments})
-    except Exception as e:
-        return JSONResponse({'error': 'Không tạo được shorts: ' + str(e)[:220]}, status_code=500)
-
-
-@app.get('/api/ai/short-file/{file_id}')
-def patched_ai_short_file(file_id: str):
-    path = os.path.join(base.SHORTS_DIR, base._safe_name(file_id) + '.mp4')
-    if not os.path.exists(path):
-        return JSONResponse({'error': 'not found'}, status_code=404)
-    return FileResponse(path, media_type='video/mp4', filename=f'vnews-ai-{file_id}.mp4')
-
-
-@app.get('/api/ai_shorts')
-def api_ai_shorts():
-    posts = [p for p in base._load_ai_wall() if p.get('video')]
-    return JSONResponse({'posts': posts[:80]})
-
-
-app.router.routes = [r for r in app.router.routes if not (getattr(r, 'path', None) == '/' and 'GET' in getattr(r, 'methods', set()))]

app_v2_entry.py

@@ -1,2166 +0,0 @@
-"""VNEWS v2 Entry Point - with fast bongda proxy + rewrite endpoints + multilingual TTS"""
-import sys, os
-from main import app, HEADERS, BONGDA_HEADERS, fetch_bongda_api, HL_LEAGUES
-
-try:
-    import ai_ext
-except Exception as e:
-    print(f"[WARN] ai_ext import failed: {e}")
-
-try:
-    import ai_patch
-except Exception as e:
-    print(f"[WARN] ai_patch import failed: {e}")
-
-from fastapi.responses import HTMLResponse, JSONResponse, FileResponse, Response
-from fastapi.staticfiles import StaticFiles
-from starlette.routing import Mount
-from fastapi import Query, Request, UploadFile, File, Form
-import requests as req
-from bs4 import BeautifulSoup
-import re, html as html_lib, json, threading, time, uuid
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from urllib.parse import quote
-import asyncio
-
-HL_LEAGUES['friendly'] = {"path": "giai-khac/friendly", "name": "Giao hữu", "emoji": "🤝"}
-
-STATIC_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'static')
-SPACE = "https://bep40-vnews.hf.space"  # SEO URL base for share links
-app.router.routes=[r for r in app.router.routes if not(getattr(r,'path',None)=='/' and hasattr(r,'methods') and 'GET' in getattr(r,'methods',set()))]
-app.routes[:]=[r for r in app.routes if not isinstance(r, Mount)]
-app.router.routes=[r for r in app.router.routes if not isinstance(r, Mount)]
-
-def _clean(s): return re.sub(r"\s+"," ",html_lib.unescape(str(s or""))).strip()
-
-# Cache for match details (5 min TTL)
-_match_cache = {}
-
-# === FAST BONGDA PROXY ENDPOINT ===
-def _get_match_detail(event_id, slug=None):
-    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36", "Accept": "text/html", "Referer": "https://bongda.com.vn/"}
-    if slug:
-        url = f"https://bongda.com.vn/tran-dau/{event_id}/centre/{slug}"
-    else:
-        url = f"https://bongda.com.vn/tran-dau/{event_id}"
-    resp = req.get(url, headers=headers, timeout=15, allow_redirects=True)
-    if resp.status_code != 200:
-        return None
-    soup = BeautifulSoup(resp.text, 'html.parser')
-    result = {"event_id": event_id, "found": False, "sections": []}
-    info = {}
-    tel = soup.select_one('.teams')
-    if tel:
-        he = tel.select_one('.team.home')
-        if he:
-            p_tags = [p for p in he.select('p') if not p.get('class') or 'logo' not in p.get('class', [])]
-            if p_tags: info['home_team'] = _clean(p_tags[0].get_text())
-            lo = he.select_one('img')
-            if lo: info['home_logo'] = lo.get('src', '')
-        ae = tel.select_one('.team.away')
-        if ae:
-            p_tags = ae.select('p')
-            team_ps = [p for p in p_tags if not p.get('class') or 'logo' not in p.get('class', [])]
-            if team_ps: info['away_team'] = _clean(team_ps[-1].get_text())
-            lo = ae.select_one('img')
-            if lo: info['away_logo'] = lo.get('src', '')
-        sc = tel.select_one('.score')
-        if sc:
-            parts = [_clean(p.get_text()) for p in sc.select('p')]
-            if len(parts) >= 2: info['score'] = f"{parts[0]} - {parts[1]}"
-            lb = sc.select_one('.label')
-            if lb: info['status_label'] = _clean(lb.get_text())
-    if info.get('home_team') and info.get('away_team'):
-        result['info'] = info
-        result['found'] = True
-        result['sections'].append('info')
-    events = []
-    for ev in soup.select('.events .period .event'):
-        ev_cls = ' '.join(ev.get('class', []))
-        ev_data = {'team': 'home' if 'home' in ev_cls else 'away', 'period': '', 'type': 'unknown', 'time': '', 'players': ''}
-        parent = ev.parent
-        if parent:
-            h2 = parent.find('h2')
-            if h2: ev_data['period'] = _clean(h2.get_text())
-        if ev.select_one('[class*="goal"]'): ev_data['type'] = 'goal'
-        elif ev.select_one('[class*="redcard"]'): ev_data['type'] = 'redcard'
-        elif ev.select_one('[class*="yellowcard"]'): ev_data['type'] = 'yellowcard'
-        elif ev.select_one('[class*="substitution"]'): ev_data['type'] = 'substitution'
-        players_el = ev.select_one('.players')
-        if players_el:
-            pl_text = _clean(players_el.get_text(' ', strip=True))
-            m = re.match(r"(\d+)'(.*)", pl_text)
-            if m:
-                ev_data['time'] = f"{m.group(1)}'"
-                ev_data['players'] = m.group(2)
-            else:
-                ev_data['players'] = pl_text
-        events.append(ev_data)
-    if events:
-        result['events'] = events
-        result['sections'].append('events')
-    pred = soup.select_one('.prediction-card')
-    if pred:
-        team_info = pred.select_one('.team-info')
-        if team_info:
-            teams = team_info.select('.team')
-            pred_data = {}
-            if len(teams) >= 2:
-                pred_data['home_name'] = _clean(teams[0].select_one('.team-name').get_text()) if teams[0].select_one('.team-name') else ''
-                pred_data['away_name'] = _clean(teams[1].select_one('.team-name').get_text()) if teams[1].select_one('.team-name') else ''
-                divider = team_info.select_one('.divider')
-                if divider: pred_data['result'] = _clean(divider.get_text())
-                vc = pred.select_one('.vote-count')
-                if vc: pred_data['vote_count'] = _clean(vc.get_text())
-            result['prediction'] = pred_data
-    recent = []
-    ml = soup.select_one('.matches-list')
-    if ml:
-        for item in ml.select('.match-detail, .match-item, li'):
-            de = item.select_one('.date, .time')
-            le = item.select_one('.league')
-            he_item = item.select_one('.home, .team-home')
-            ae_item = item.select_one('.away, .team-away')
-            se = item.select_one('.score, .result')
-            if he_item or ae_item:
-                recent.append({'date': _clean(de.get_text()) if de else '', 'league': _clean(le.get_text()) if le else '', 'home': _clean(he_item.get_text()) if he_item else '', 'away': _clean(ae_item.get_text()) if ae_item else '', 'score': _clean(se.get_text()) if se else 'vs'})
-    if recent:
-        result['recent_matches'] = recent
-        result['sections'].append('recent')
-    try:
-        api_h = {"User-Agent": "Mozilla/5.0", "Accept": "application/json", "X-Requested-With": "XMLHttpRequest", "Referer": "https://bongda.com.vn/"}
-        ar = req.get(f"https://bongda.com.vn/api/fixtures/h2h-stats?event_id={event_id}", headers=api_h, timeout=10)
-        if ar.status_code == 200:
-            ad = ar.json()
-            if ad.get('status') == 'success' and ad.get('html'):
-                asp = BeautifulSoup(ad['html'], 'html.parser')
-                ast = {}
-                for row in asp.select('li, tr'):
-                    cells = row.select('td, span, p')
-                    if len(cells) >= 3:
-                        lb = _clean(cells[0].get_text())
-                        if lb: ast[lb] = {'home': _clean(cells[1].get_text()), 'away': _clean(cells[2].get_text())}
-                if ast:
-                    result['h2h_stats_parsed'] = ast
-                    result['sections'].append('h2h_stats')
-    except: pass
-    return result
-
-@app.get('/api/proxy/bongda')
-def proxy_bongda(event_id: int = Query(default=None), slug: str = Query(default=None)):
-    if event_id is None:
-        return JSONResponse({'error': 'event_id required'}, status_code=400)
-    cache_key = f"{event_id}_{slug}"
-    now = time.time()
-    cached = _match_cache.get(cache_key)
-    if cached and now - cached.get('_ts', 0) < 300:
-        return JSONResponse(cached)
-    try:
-        result = _get_match_detail(event_id, slug)
-        if result:
-            result['_ts'] = now
-            _match_cache[cache_key] = result
-            return JSONResponse(result)
-    except Exception as e:
-        err = {"event_id": event_id, "found": False, "error": str(e), "_ts": now}
-        _match_cache[cache_key] = err
-        return JSONResponse(err)
-    return JSONResponse({"event_id": event_id, "found": False})
-
-@app.get('/api/match/{event_id}/detail')
-def api_match_detail(event_id: int, url: str = Query(default=None)):
-    slug = None
-    if url:
-        m = re.match(r'.+/tran-dau/\d+/(?:centre|preview)/(.+)', url)
-        if m:
-            slug = m.group(1)
-    cache_key = f"{event_id}_{slug or ''}"
-    now = time.time()
-    cached = _match_cache.get(cache_key)
-    if cached and now - cached.get('_ts', 0) < 300:
-        return JSONResponse(cached)
-    try:
-        if not slug:
-            try:
-                home_r = req.get("https://bongda.com.vn/", headers={"User-Agent": "Mozilla/5.0"}, timeout=10)
-                if home_r.status_code == 200:
-                    home_soup = BeautifulSoup(home_r.text, 'html.parser')
-                    for a in home_soup.select(f'a[href*="/tran-dau/{event_id}/"]'):
-                        href = a.get('href', '')
-                        m = re.match(r'/tran-dau/\d+/(?:centre|preview)/(.+)', href)
-                        if m:
-                            slug = m.group(1)
-                            cache_key = f"{event_id}_{slug}"
-                            break
-            except: pass
-        result = _get_match_detail(event_id, slug)
-        if result:
-            result['_ts'] = now
-            _match_cache[cache_key] = result
-            return JSONResponse(result)
-    except Exception as e:
-        err = {"event_id": event_id, "found": False, "error": str(e), "_ts": now}
-        _match_cache[cache_key] = err
-        return JSONResponse(err)
-    return JSONResponse({"event_id": event_id, "found": False})
-
-_STOP=set('và của các những một được trong với cho tại sau trước khi không người việt nam hôm nay mới nhất nóng tin tức cập nhật theo từ đến là có thì này đã để'.split())
-
-def _has_kw(topic,title):
-    tl=topic.lower();tt=(title or'').lower()
-    if tl in tt:return True
-    words=[w for w in re.findall(r'[A-Za-zÀ-ỹ0-9]+',tl) if len(w)>2 and w not in _STOP]
-    if not words:return True
-    return any(w in tt for w in words)
-
-def _s_vnexpress(topic,limit=8):
-    items=[]
-    try:
-        r=req.get(f"https://timkiem.vnexpress.net/?q={quote(topic)}",headers={'User-Agent':'Mozilla/5.0'},timeout=10);soup=BeautifulSoup(r.text,'lxml')
-        for art in soup.select('article.item-news')[:limit]:
-            a=art.select_one('h2 a, h3 a')
-            if a and a.get('href'):
-                t=_clean(a.get('title','') or a.get_text(strip=True))
-                if _has_kw(topic,t):items.append({'title':t,'url':a['href'],'via':'VnExpress'})
-    except:pass
-    return items
-
-def _s_dantri(topic,limit=8):
-    items=[]
-    try:
-        r=req.get(f"https://dantri.com.vn/tim-kiem/{quote(topic)}.htm",headers={'User-Agent':'Mozilla/5.0'},timeout=10);soup=BeautifulSoup(r.text,'lxml')
-        for a in soup.select('h3 a[href], .article-title a[href]')[:limit*2]:
-            t=_clean(a.get_text(strip=True));href=a.get('href','')
-            if t and len(t)>15 and _has_kw(topic,t):
-                if not href.startswith('http'):href='https://dantri.com.vn'+href
-                items.append({'title':t,'url':href,'via':'Dân Trí'})
-            if len(items)>=limit:break
-    except:pass
-    return items
-
-def _s_vietnamnet(topic,limit=6):
-    items=[]
-    try:
-        r=req.get(f"https://vietnamnet.vn/tim-kiem?q={quote(topic)}",headers={'User-Agent':'Mozilla/5.0'},timeout=10);soup=BeautifulSoup(r.text,'lxml')
-        for a in soup.select('h3 a[href], .vnn-title a')[:limit*2]:
-            t=_clean(a.get('title','') or a.get_text(strip=True));href=a.get('href','')
-            if t and len(t)>15 and _has_kw(topic,t):
-                if not href.startswith('http'):href='https://vietnamnet.vn'+href
-                items.append({'title':t,'url':href,'via':'VietNamNet'})
-            if len(items)>=limit:break
-    except:pass
-    return items
-
-def _s_bongda(topic,limit=5):
-    items=[]
-    try:
-        r=req.get(f"https://bongda.com.vn/tim-kiem.html?q={quote(topic)}",headers={'User-Agent':'Mozilla/5.0'},timeout=8);soup=BeautifulSoup(r.text,'lxml')
-        for a in soup.select('h3 a[href], .title a[href]')[:limit*2]:
-            t=_clean(a.get_text(strip=True));href=a.get('href','')
-            if t and len(t)>15 and _has_kw(topic,t):
-                if not href.startswith('http'):href='https://bongda.com.vn'+href
-                items.append({'title':t,'url':href,'via':'Bóng Đá'})
-            if len(items)>=limit:break
-    except:pass
-    return items
-
-def _s_genk(topic,limit=5):
-    items=[]
-    try:
-        r=req.get(f"https://genk.vn/tim-kiem?q={quote(topic)}",headers={'User-Agent':'Mozilla/5.0'},timeout=8);soup=BeautifulSoup(r.text,'lxml')
-        for a in soup.select('a[href$=".chn"]')[:limit*3]:
-            t=_clean(a.get('title','') or a.get_text(strip=True));href=a.get('href','')
-            if t and len(t)>15 and _has_kw(topic,t):
-                if href.startswith('/'):href='https://genk.vn'+href
-                items.append({'title':t,'url':href,'via':'GenK'})
-            if len(items)>=limit:break
-    except:pass
-    return items
-
-def _s_thanhnien(topic,limit=6):
-    items=[]
-    try:
-        r=req.get(f"https://thanhnien.vn/tim-kiem?q={quote(topic)}",headers={'User-Agent':'Mozilla/5.0'},timeout=10);soup=BeautifulSoup(r.text,'lxml')
-        for a in soup.select('h3 a[href], .box-title a')[:limit*2]:
-            t=_clean(a.get('title','') or a.get_text(strip=True));href=a.get('href','')
-            if t and len(t)>15 and _has_kw(topic,t):
-                if not href.startswith('http'):href='https://thanhnien.vn'+href
-                items.append({'title':t,'url':href,'via':'Thanh Niên'})
-            if len(items)>=limit:break
-    except:pass
-    return items
-
-def _s_tuoitre(topic,limit=6):
-    items=[]
-    try:
-        r=req.get(f"https://tuoitre.vn/tim-kiem.htm?keywords={quote(topic)}",headers={'User-Agent':'Mozilla/5.0'},timeout=10);soup=BeautifulSoup(r.text,'lxml')
-        for a in soup.select('h3 a[href], .box-title-text a')[:limit*2]:
-            t=_clean(a.get('title','') or a.get_text(strip=True));href=a.get('href','')
-            if t and len(t)>15 and _has_kw(topic,t):
-                if not href.startswith('http'):href='https://tuoitre.vn'+href
-                items.append({'title':t,'url':href,'via':'Tuổi Trẻ'})
-            if len(items)>=limit:break
-    except:pass
-    return items
-
-def _s_thethaovanhoa(topic,limit=5):
-    items=[]
-    try:
-        r=req.get(f"https://thethaovanhoa.vn/tim-kiem.htm?keyword={quote(topic)}",headers={'User-Agent':'Mozilla/5.0'},timeout=8);soup=BeautifulSoup(r.text,'lxml')
-        for a in soup.select('h3 a[href], .title a[href]')[:limit*2]:
-            t=_clean(a.get('title','') or a.get_text(strip=True));href=a.get('href','')
-            if t and len(t)>15 and _has_kw(topic,t):
-                if not href.startswith('http'):href='https://thethaovanhoa.vn'+href
-                items.append({'title':t,'url':href,'via':'TT&VH'})
-            if len(items)>=limit:break
-    except:pass
-    return items
-
-def _search_all(topic,limit=36):
-    results={}
-    with ThreadPoolExecutor(8) as ex:
-        futs={ex.submit(_s_vnexpress,topic,8):'vne',ex.submit(_s_dantri,topic,8):'dt',ex.submit(_s_vietnamnet,topic,6):'vnn',ex.submit(_s_bongda,topic,5):'bd',ex.submit(_s_genk,topic,5):'gk',ex.submit(_s_thanhnien,topic,6):'tn',ex.submit(_s_tuoitre,topic,6):'tt',ex.submit(_s_thethaovanhoa,topic,5):'tvh'}
-        for f in as_completed(futs,timeout=14):
-            try:results[futs[f]]=f.result()
-            except:results[futs[f]]=[]
-    srcs=list(results.values());out=[];seen=set()
-    for i in range(max((len(s) for s in srcs),default=0)):
-        for s in srcs:
-            if i<len(s) and s[i].get('url') and s[i]['url'] not in seen:seen.add(s[i]['url']);out.append(s[i])
-    return out[:limit]
-
-for _path in ['/api/article', '/api/hot_topics', '/api/categories', '/api/storage_status']:
-    app.router.routes=[r for r in app.router.routes if not(getattr(r,'path',None)==_path and 'GET' in getattr(r,'methods',set()))]
-
-_article_cache = {}
-_article_cache_ttl = 1800
-
-_art_session = None
-_art_lock = threading.Lock()
-def _get_art_session():
-    global _art_session
-    if _art_session is None:
-        with _art_lock:
-            if _art_session is None:
-                _art_session = req.Session()
-                _art_session.headers.update({
-                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-                    "Accept-Language": "vi-VN,vi;q=0.9,en;q=0.8",
-                    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-                })
-    return _art_session
-
-def _scrape_article_fast(url):
-    from urllib.parse import urlparse
-    domain = urlparse(url).netloc
-    sess = _get_art_session()
-    uas = [
-        {"User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1"},
-        {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"},
-    ]
-    for ua in uas:
-        try:
-            r = sess.get(url, headers=ua, timeout=6, allow_redirects=True)
-            if not r or r.status_code != 200:
-                continue
-            r.encoding = 'utf-8'
-            soup = BeautifulSoup(r.text, 'lxml')
-            for tag in soup.find_all(['script','style','nav','footer','aside','form','noscript','iframe','.ads','.ad','.banner-ads','.fb-comments','.fb-root','.social-share','.related-news','.tag','.breadcrumb']):
-                tag.decompose()
-            title = summary = og_img = ""
-            ogt = soup.find('meta', property='og:title')
-            if ogt: title = ogt.get('content', '')
-            ogd = soup.find('meta', property='og:description') or soup.find('meta', attrs={'name': 'description'})
-            if ogd: summary = ogd.get('content', '')[:500]
-            ogi = soup.find('meta', property='og:image')
-            if ogi:
-                og_img = ogi.get('content', '')
-                if og_img.startswith('//'): og_img = 'https:' + og_img
-            h1 = soup.find('h1')
-            if not title and h1: title = h1.get_text(strip=True)[:200]
-            body = []
-            selectors = [
-                '.fck_detail', '.sidebar-1',
-                '.singular-content', '.dt__content', '.article-content', '.content-detail', '#divNewsContent',
-                '.content-detail', '.main-content-detail', '.box-content',
-                '.knc-content', '.article-body', '.detail-body',
-                '.article-detail', '.detail-content',
-                'article', 'main', '.cms-body', '.article__body', '.post-content',
-                '.entry-content', '#content', '.article-text', '.story-body',
-            ]
-            for sel in selectors:
-                el = soup.select_one(sel)
-                if el and len(el.find_all('p')) >= 2:
-                    seen_imgs = set()
-                    for child in el.find_all(['p','h2','h3','figure','img'], recursive=True):
-                        if child.name == 'p':
-                            t = child.get_text(strip=True)
-                            if t and len(t) > 15:
-                                body.append({'type': 'p', 'text': t})
-                        elif child.name in ('h2','h3'):
-                            t = child.get_text(strip=True)
-                            if t:
-                                body.append({'type': 'heading', 'text': t})
-                        elif child.name in ('figure','img'):
-                            im = child if child.name == 'img' else child.find('img')
-                            if im:
-                                src = im.get('data-src') or im.get('src') or im.get('data-lazy') or ''
-                                if src and 'base64' not in src and src not in seen_imgs:
-                                    seen_imgs.add(src)
-                                    if src.startswith('//'): src = 'https:' + src
-                                    body.append({'type': 'img', 'src': src})
-                        if child.name == 'figure':
-                            cap = child.find('figcaption')
-                            if cap:
-                                ct = cap.get_text(strip=True)
-                                if ct: body.append({'type': 'p', 'text': ct})
-                    if len(body) >= 2:
-                        return {'title': _clean(title), 'summary': _clean(summary), 'og_image': og_img,
-                                'body': body[:50], 'source': domain, 'url': url}
-            if title and (summary or og_img):
-                fallback = []
-                if og_img: fallback.append({'type': 'img', 'src': og_img})
-                if summary: fallback.append({'type': 'p', 'text': summary})
-                if fallback:
-                    return {'title': _clean(title), 'summary': _clean(summary), 'og_image': og_img,
-                            'body': fallback, 'source': domain, 'url': url, 'fallback': True}
-            if title:
-                return {'title': _clean(title), 'summary': '', 'og_image': '',
-                        'body': [{'type': 'p', 'text': 'Nội dung đang được tải...'}],
-                        'source': domain, 'url': url, 'fallback': True}
-            break
-        except Exception:
-            continue
-    return None
-
-@app.get('/api/article')
-def api_article_v2(url: str = Query(...)):
-    from urllib.parse import unquote
-    safe_url = unquote(url)
-    try:
-        now = time.time()
-        cached = _article_cache.get(safe_url)
-        if cached and now - cached['t'] < _article_cache_ttl:
-            resp = JSONResponse(cached['d'])
-            resp.headers["Cache-Control"] = "public, max-age=1800"
-            return resp
-        data = _scrape_article_fast(safe_url)
-        if data and data.get('body'):
-            _article_cache[safe_url] = {'d': data, 't': now}
-            resp = JSONResponse(data)
-            resp.headers["Cache-Control"] = "public, max-age=1800"
-            return resp
-        result = {'error': 'Không đọc được', 'url': safe_url}
-        resp = JSONResponse(result)
-        resp.headers["Cache-Control"] = "public, max-age=60"
-        return resp
-    except Exception as e:
-        return JSONResponse({'error': f'Server error: {str(e)[:100]}', 'url': safe_url}, status_code=200)
-
-_hot_cache={'t':0,'d':[]}
-def _get_hot_topics():
-    now=time.time()
-    if _hot_cache['d'] and now-_hot_cache['t']<600:return _hot_cache['d']
-    freq={};display={}
-    feeds=['https://vnexpress.net/rss/tin-moi-nhat.rss','https://dantri.com.vn/rss/home.rss','https://vietnamnet.vn/rss/tin-moi-nhat.rss','https://thanhnien.vn/rss/home.rss','https://tuoitre.vn/rss/tin-moi-nhat.rss','https://genk.vn/rss','https://vnexpress.net/rss/the-thao.rss','https://thethaovanhoa.vn/rss/tin-nong.rss']
-    for feed_url in feeds:
-        try:
-            r=req.get(feed_url,headers={'User-Agent':'Mozilla/5.0'},timeout=6);r.encoding='utf-8';soup=BeautifulSoup(r.text,'xml')
-            for item in soup.find_all('item')[:12]:
-                title=_clean(item.find('title').get_text() if item.find('title') else '')
-                if not title:continue
-                title=re.sub(r'\s*[-|].*$','',title);words=[w for w in re.findall(r'[A-Za-zÀ-ỹ0-9]+',title) if len(w)>2 and w.lower() not in _STOP]
-                if len(words)<2:continue
-                for n in(3,4,2):
-                    for i in range(max(0,len(words)-n+1)):
-                        phrase=' '.join(words[i:i+n])
-                        if 8<=len(phrase)<=45:key=phrase.lower();freq[key]=freq.get(key,0)+1;display[key]=phrase
-        except:continue
-    ranked=sorted(freq.items(),key=lambda x:x[1],reverse=True);topics=[];seen=set()
-    for key,count in ranked:
-        is_dup=any(len(set(e.split())&set(key.split()))/max(len(set(e.split())),len(set(key.split())),1)>0.6 for e in seen)
-        if is_dup:continue
-        seen.add(key);topics.append({'label':'#'+re.sub(r'\s+','',display[key].title()),'topic':display[key],'count':count})
-        if len(topics)>=20:break
-    for kw in['World Cup 2026','Kinh tế Việt Nam','Bóng đá châu Âu','Công nghệ AI','Giá vàng','Thời tiết']:
-        if len(topics)>=24:break
-        if not any(kw.lower() in s for s in seen):topics.append({'label':'#'+re.sub(r'\s+','',kw.title()),'topic':kw,'count':0})
-    _hot_cache.update({'t':now,'d':topics[:24]});return topics[:24]
-
-@app.get('/api/hot_topics')
-def api_hot_topics():
-    resp = JSONResponse({'topics':_get_hot_topics()})
-    resp.headers["Cache-Control"] = "public, max-age=120"
-    return resp
-@app.get('/')
-async def serve_index():
-    p=os.path.join(STATIC_DIR,'index_v2.html')
-    if os.path.exists(p):return FileResponse(p,media_type='text/html')
-    return HTMLResponse('<h1>VNEWS</h1>')
-@app.get('/api/hashtag/sources')
-def _ht(topic:str=Query(...),page:int=Query(default=0)):
-    items=_search_all(topic,36);per_page=8;start=page*per_page;end=start+per_page
-    return JSONResponse({'sources':items[start:end],'topic':topic,'page':page,'has_more':end<len(items),'total':len(items)})
-@app.get('/api/categories')
-def _cat():return JSONResponse([])
-@app.get('/api/storage_status')
-def _st():return JSONResponse({'persistent':os.path.isdir('/data') and os.access('/data',os.W_OK)})
-# ===== SHARE HELPERS: render content pages for shared links =====
-def _render_slides_page(post, safe_title, safe_img, safe_url):
-    slides = post.get('slides', [])
-    # Get image from post.img or first slide's image
-    if not safe_img and slides and slides[0].get('image'):
-        safe_img = slides[0].get('image', '')
-    # Use text for description if available
-    description = _clean((post.get('text') or '')[:200]) or "Tin tức tóm tắt, AI rewrite, World Cup 2026"
-    
-    # Build canonical URL preserving original query format if url was provided
-    if safe_url and safe_url != '/':
-        canonical_url = f"{SPACE}/s?url={quote(safe_url)}&title={quote(safe_title[:100])}"
-    else:
-        canonical_url = f"{SPACE}/s?post_id={post.get('id') or ''}"
-    
-    h = f'''<!DOCTYPE html>
-<html lang="vi">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width,initial-scale=1">
-<title>{_clean(safe_title)}</title>
-<meta property="og:title" content="{_clean(safe_title)}">
-<meta property="og:image" content="{_clean(safe_img)}">
-<meta property="og:description" content="{description}">
-<meta property="og:url" content="{canonical_url}">
-<link rel="canonical" href="{canonical_url}">
-<style>
-*{{box-sizing:border-box;margin:0;padding:0}}body{{background:#111;color:#eee;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;padding:12px}}
-.slide-card{{background:#1a1a1a;border:1px solid #2a2a2a;border-radius:12px;padding:16px;margin-bottom:12px;max-width:600px;margin-left:auto;margin-right:auto}}
-.slide-num{{color:#5cb87a;font-size:12px;font-weight:700;margin-bottom:6px}}
-.slide-img{{width:100%;max-height:300px;object-fit:cover;border-radius:8px;margin-bottom:8px}}
-.slide-text{{color:#ddd;font-size:14px;line-height:1.6;margin:0}}
-</style>
-</head>
-<body>'''
-    for s in slides:
-        img_src = s.get('image', '')
-        if img_src and ('cdnphoto.dantri' in img_src or 'refooty' in img_src or 'vnexpress' in img_src or 'vcdn' in img_src):
-            img_tag = f'<img src="/api/proxy/img?url={quote(img_src, safe="")}" class="slide-img" loading="lazy" onerror="this.style.display=\'none\'">'
-        else:
-            img_tag = f'<img src="{_clean(img_src)}" class="slide-img" loading="lazy" onerror="this.style.display=\'none\'">' if img_src else ''
-        h += f'<div class="slide-card"><div class="slide-num">Slide {s.get("index",1)}/{len(slides)}</div>{img_tag}<p class="slide-text">{_clean(s.get("text",""))}</p></div>'
-    h += '</body></html>'
-    return HTMLResponse(h)
-
-def _render_video_page(post, safe_title, safe_img, safe_url):
-    video_url = post.get('video', '')
-    # Use text for description if available
-    description = _clean((post.get('text') or '')[:200]) or "Tin tức tóm tắt, AI rewrite, World Cup 2026"
-    
-    # Build canonical URL preserving original query format if url was provided
-    if safe_url and safe_url != '/':
-        canonical_url = f"{SPACE}/s?url={quote(safe_url)}&title={quote(safe_title[:100])}"
-    else:
-        canonical_url = f"{SPACE}/s?post_id={post.get('id') or ''}"
-    
-    h = f'''<!DOCTYPE html>
-<html lang="vi">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no">
-<title>{_clean(safe_title)}</title>
-<meta property="og:title" content="{_clean(safe_title)}">
-<meta property="og:image" content="{_clean(safe_img)}">
-<meta property="og:description" content="{description}">
-<meta property="og:url" content="{canonical_url}">
-<link rel="canonical" href="{canonical_url}">
-<meta name="twitter:card" content="player">
-<meta name="twitter:player" content="{video_url}">
-<style>
-*{{box-sizing:border-box;margin:0;padding:0}}body{{background:#111;color:#eee;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;padding:0;overflow:hidden}}
-.video-container{{width:100vw;height:100vh;display:flex;flex-direction:column;align-items:center;justify-content:center;background:#000}}
-video{{width:100%;height:100%;max-height:100vh;object-fit:contain;background:#000}}
-.title-bar{{position:fixed;bottom:0;left:0;right:0;background:linear-gradient(transparent,rgba(0,0,0,.8));padding:40px 16px 16px;text-align:center}}
-.title-text{{color:#fff;font-size:13px;line-height:1.4;max-width:600px;margin:0 auto}}
-</style>
-</head>
-<body>
-<div class="video-container">
-<video src="{_clean(video_url)}" controls autoplay playsinline loop></video>
-<div class="title-bar"><div class="title-text">{_clean(safe_title)}</div></div>
-</div>
-</body></html>'''
-    return HTMLResponse(h)
-
-@app.get('/s/{slug}')
-async def _sh_slug(slug: str, request: Request, url: str = '', title: str = '', img: str = ''):
-    """SEO-friendly share endpoint with slug in URL path.
-    Shows slide content when slug matches a wall post ID, otherwise redirects.
-    """
-    safe_title = _clean(title) if title else 'VNEWS - Tin tức'
-    safe_img = _clean(img) if img else ''
-    safe_url = _clean(url) if url else '/'
-    
-    # Try to find post by slug (post ID)
-    post = None
-    try:
-        if slug and len(slug) > 5:  # Likely a post ID
-            posts = _load_wall_posts()
-            for p in posts:
-                if p.get('id') == slug:
-                    post = p
-                    safe_title = p.get('title', safe_title) or safe_title
-                    safe_img = p.get('img', safe_img) or safe_img
-                    safe_url = p.get('url', safe_url) or safe_url
-                    break
-    except:
-        pass
-    
-    if post and post.get('slides'):
-        return _render_slides_page(post, safe_title, safe_img, safe_url)
-    
-    if post and post.get('video'):
-        return _render_video_page(post, safe_title, safe_img, safe_url)
-    
-    # Otherwise redirect
-    return HTMLResponse(f'''<!DOCTYPE html>
-<html lang="vi">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width,initial-scale=1">
-<title>{_clean(safe_title)}</title>
-<meta property="og:title" content="{_clean(safe_title)}">
-<meta property="og:image" content="{_clean(safe_img)}">
-<meta property="og:description" content="Tin tức tóm tắt, AI rewrite, World Cup 2026">
-<meta property="og:url" content="{SPACE}/s/{slug}">
-<link rel="canonical" href="{SPACE}/s/{slug}">
-<meta http-equiv="refresh" content="0;url={safe_url}">
-</head><body></body></html>''')
-
-@app.get('/s')
-async def _sh(url:str='',title:str='',img:str='',post_id:str=''):
-    safe_title = _clean(title) if title else 'VNEWS - Tin tức'
-    safe_img = _clean(img) if img else ''
-    safe_url = _clean(url) if url else '/'
-    
-    # Try to find wall post by post_id or URL (prioritize posts with slides/video)
-    post = None
-    try:
-        posts = _load_wall_posts()
-        if post_id:
-            for p in posts:
-                if p.get('id') == post_id:
-                    post = p
-                    safe_title = p.get('title', safe_title) or safe_title
-                    safe_img = p.get('img', safe_img) or safe_img
-                    safe_url = p.get('url', safe_url) or safe_url
-                    break
-        elif url:
-            # Find matching URL - prioritize posts with slides or video
-            for p in posts:
-                if p.get('url') == url and p.get('slides'):
-                    post = p
-                    safe_title = p.get('title', safe_title) or safe_title
-                    safe_img = p.get('img', safe_img) or safe_img
-                    safe_url = p.get('url', safe_url) or safe_url
-                    break
-            if not post:
-                # Fallback: find any matching URL
-                for p in posts:
-                    if p.get('url') == url:
-                        post = p
-                        safe_title = p.get('title', safe_title) or safe_title
-                        safe_img = p.get('img', safe_img) or safe_img
-                        safe_url = p.get('url', safe_url) or safe_url
-                        break
-    except:
-        pass
-    
-    if post and post.get('slides'):
-        return _render_slides_page(post, safe_title, safe_img, safe_url)
-    
-    if post and post.get('video'):
-        return _render_video_page(post, safe_title, safe_img, safe_url)
-    
-    # Fallback: redirect to original URL
-    return HTMLResponse(f'''<!DOCTYPE html>
-<html lang="vi">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width,initial-scale=1">
-<title>{safe_title}</title>
-<meta property="og:title" content="{safe_title}">
-<meta property="og:image" content="{safe_img}">
-<meta property="og:description" content="Tin tức tóm tắt, AI rewrite, World Cup 2026">
-<meta property="og:url" content="{SPACE}/s?url={quote(safe_url)}">
-<link rel="canonical" href="{SPACE}/s?url={quote(safe_url)}">
-<meta http-equiv="refresh" content="0;url={safe_url}">
-</head><body></body></html>''')
-
-from wc2026_scraper import scrape_summary,scrape_fixtures,scrape_standings,scrape_stats,scrape_wc_news,scrape_road_to_wc,get_wc2026_all,scrape_history,scrape_h2h,scrape_lineups,scrape_match_detail
-
-_xlb_cache = {}
-_xlb_lock = threading.Lock()
-
-def _xlb_scrape(path):
-    url = f"https://xemlaibongda.top/{path}"
-    r = req.get(url, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}, timeout=15, allow_redirects=True)
-    if r.status_code != 200:
-        return []
-    soup = BeautifulSoup(r.text, 'lxml')
-    vids = []
-    seen = set()
-    for a in soup.select('a[href*="/video/"]'):
-        href = a.get('href', '')
-        if not href or href in seen:
-            continue
-        seen.add(href)
-        if not href.startswith('http'):
-            href = 'https://xemlaibongda.top' + href
-        img = a.select_one('img')
-        p = a.parent
-        for _ in range(4):
-            if img:
-                break
-            if p:
-                img = p.select_one('img')
-                p = p.parent
-        img_src = ''
-        if img:
-            img_src = img.get('data-src','') or img.get('src','') or img.get('data-lazy','') or img.get('data-original','')
-            if img_src.startswith('//'):
-                img_src = 'https:' + img_src
-            elif img_src.startswith('/'):
-                img_src = 'https://xemlaibongda.top' + img_src
-        title = ''
-        for sel in ['.title', 'h3', 'h2', '.name', '.post-title', '.entry-title', '.video-title']:
-            t = a.select_one(sel)
-            if t:
-                title = _clean(t.get_text())
-                break
-        if not title:
-            title = _clean(a.get('title',''))
-        if not title:
-            img_alt = a.select_one('img')
-            if img_alt:
-                title = _clean(img_alt.get('alt',''))
-        if not title:
-            parent = a.parent
-            if parent:
-                pt = _clean(parent.get_text(' ',strip=True))
-                if 5 < len(pt) < 120:
-                    title = pt
-        if not title or len(title) < 3:
-            continue
-        vids.append({"link": href, "img": img_src, "title": title})
-        if len(vids) >= 30:
-            break
-    return vids
-
-@app.get('/api/proxy/xlb')
-def proxy_xlb(path: str = Query(default="")):
-    now = time.time()
-    cache_key = f"xlb:{path}"
-    with _xlb_lock:
-        cached = _xlb_cache.get(cache_key)
-        if cached and now - cached['t'] < 120:
-            return JSONResponse(cached['d'])
-    try:
-        vids = _xlb_scrape(path)
-        result = {"videos": vids, "count": len(vids)}
-        with _xlb_lock:
-            _xlb_cache[cache_key] = {'t': now, 'd': result}
-        return JSONResponse(result)
-    except Exception as e:
-        return JSONResponse({"videos": [], "count": 0, "error": str(e)}, status_code=500)
-
-@app.get('/api/wc2026')
-def _w():return JSONResponse(get_wc2026_all())
-@app.get('/api/wc2026/fixtures')
-def _wf():return JSONResponse(scrape_fixtures())
-@app.get('/api/wc2026/standings')
-def _ws():return JSONResponse(scrape_standings())
-@app.get('/api/wc2026/stats')
-def _wst():return JSONResponse(scrape_stats())
-@app.get('/api/wc2026/history')
-def _whi():return JSONResponse(scrape_history())
-@app.get('/api/wc2026/news')
-def _wn():return JSONResponse(scrape_wc_news())
-@app.get('/api/wc2026/road')
-def _wr():return JSONResponse(scrape_road_to_wc())
-@app.get('/api/wc2026/h2h/{eid}')
-def _wh2(eid:int):return JSONResponse(scrape_h2h(eid))
-@app.get('/api/wc2026/lineups/{eid}')
-def _wl(eid:int):return JSONResponse(scrape_lineups(eid))
-@app.get('/api/wc2026/match/{eid}')
-def _wm(eid:int):return JSONResponse(scrape_match_detail(eid))
-
-DATA_DIR='/data' if os.path.isdir('/data') else os.path.join(os.path.dirname(os.path.abspath(__file__)),'data')
-os.makedirs(DATA_DIR,exist_ok=True)
-IF=os.path.join(DATA_DIR,'interactions_v2.json')
-CF=os.path.join(DATA_DIR,'comments_v2.json')
-WALL_FILE=os.path.join(DATA_DIR,'wall_posts.json')
-WALL_VIDEO_DIR=os.path.join(DATA_DIR,'wall_videos')
-os.makedirs(WALL_VIDEO_DIR,exist_ok=True)
-
-_il=threading.Lock();_cl=threading.Lock();_wl_lock=threading.Lock()
-def _lj(p):
-    try:
-        if os.path.exists(p):return json.load(open(p,'r',encoding='utf-8'))
-    except:pass
-    return{}
-def _sj(p,d):
-    try:open(p+'.tmp','w',encoding='utf-8').write(json.dumps(d,ensure_ascii=False));os.replace(p+'.tmp',p)
-    except:pass
-
-@app.post('/api/v2/interact')
-async def _int(request:Request):
-    b=await request.json();v=str(b.get('id','')).strip();t=str(b.get('type','')).strip()
-    if not v or t not in('view','like'):return JSONResponse({'error':'x'},status_code=400)
-    with _il:db=_lj(IF);db.setdefault(v,{'views':0,'likes':0,'comments':0});db[v][t+'s']+=1;_sj(IF,db);return JSONResponse(db[v])
-
-@app.get('/api/v2/interactions')
-def _gi(id:str=Query(...)):
-    with _il:return JSONResponse(_lj(IF).get(id.strip(),{'views':0,'likes':0,'comments':0}))
-
-@app.get('/api/v2/comments')
-def _gc(id:str=Query(...)):
-    with _cl:return JSONResponse({'comments':_lj(CF).get(id.strip(),[])})
-
-@app.post('/api/v2/comment')
-async def _pc(request:Request):
-    b=await request.json();v=str(b.get('id','')).strip();tx=str(b.get('text','')).strip()[:500]
-    if not v or not tx:return JSONResponse({'error':'x'},status_code=400)
-    c={'text':tx,'time':time.strftime('%H:%M %d/%m',time.localtime()),'ts':int(time.time())}
-    with _cl:db=_lj(CF);db.setdefault(v,[]);db[v].append(c);db[v]=db[v][-200:];_sj(CF,db);cms=db[v]
-    with _il:idb=_lj(IF);idb.setdefault(v,{'views':0,'likes':0,'comments':0});idb[v]['comments']=len(cms);_sj(IF,idb)
-    return JSONResponse({'comments':cms})
-
-def _load_wall_posts():
-    with _wl_lock:
-        return _lj(WALL_FILE)
-
-def _save_wall_posts(posts):
-    with _wl_lock:
-        _sj(WALL_FILE, posts)
-
-@app.get('/api/wall')
-def api_wall():
-    posts = _load_wall_posts()
-    if not posts:
-        return JSONResponse({"posts": []})
-    return JSONResponse({"posts": posts})
-
-@app.post('/api/wall')
-async def api_wall_post(request: Request):
-    content_type = request.headers.get('content-type', '')
-    if 'multipart/form-data' in content_type:
-        try:
-            form = await request.form()
-        except Exception as e:
-            return JSONResponse({"error": f"Form parse error: {str(e)}"}, status_code=400)
-        title = form.get('title', 'Video mới') or 'Video mới'
-        text = form.get('text', '') or ''
-        source = form.get('source', 'vtv_recorder') or 'vtv_recorder'
-        video_file = form.get('video')
-        post_id = str(uuid.uuid4())[:12]
-        video_url = None
-        if video_file and hasattr(video_file, 'filename') and video_file.filename:
-            fname = video_file.filename.lower()
-            if fname.endswith('.mp4'):
-                ext = '.mp4'
-            elif fname.endswith('.webm'):
-                ext = '.webm'
-            else:
-                ext = '.webm'
-            video_filename = f"wall_{post_id}{ext}"
-            video_path = os.path.join(WALL_VIDEO_DIR, video_filename)
-            try:
-                content = await video_file.read()
-                if not content:
-                    return JSONResponse({"error": "Empty video file"}, status_code=400)
-                with open(video_path, 'wb') as f:
-                    f.write(content)
-                file_size_mb = len(content) / 1024 / 1024
-                if file_size_mb > 50:
-                    os.remove(video_path)
-                    return JSONResponse({"error": f"Video quá lớn ({file_size_mb:.1f}MB). Tối đa 50MB."}, status_code=400)
-                video_url = f"/api/wall/video/{video_filename}"
-            except Exception as e:
-                return JSONResponse({"error": f"Lỗi lưu video: {str(e)}"}, status_code=500)
-        post = {
-            "id": post_id,
-            "title": title[:200],
-            "text": text[:2000],
-            "source": source,
-            "video": video_url,
-            "img": None,
-            "images": [],
-            "created": int(time.time()),
-            "created_str": time.strftime('%H:%M %d/%m/%Y', time.localtime()),
-        }
-        posts = _load_wall_posts()
-        if not isinstance(posts, list):
-            posts = []
-        posts.insert(0, post)
-        posts = posts[:200]
-        _save_wall_posts(posts)
-        return JSONResponse({"post": post, "ok": True})
-    try:
-        body = await request.json()
-    except:
-        body = {}
-    title = body.get('title', 'Bài mới') or 'Bài mới'
-    text = body.get('text', '') or ''
-    img = body.get('img', None)
-    source = body.get('source', 'user') or 'user'
-    post_id = str(uuid.uuid4())[:12]
-    post = {
-        "id": post_id,
-        "title": title[:200],
-        "text": text[:2000],
-        "source": source,
-        "video": None,
-        "img": img,
-        "images": [],
-        "created": int(time.time()),
-        "created_str": time.strftime('%H:%M %d/%m/%Y', time.localtime()),
-    }
-    posts = _load_wall_posts()
-    if not isinstance(posts, list):
-        posts = []
-    posts.insert(0, post)
-    posts = posts[:200]
-    _save_wall_posts(posts)
-    return JSONResponse({"post": post, "ok": True})
-
-@app.get('/api/wall/video/{filename}')
-def api_wall_video(filename: str):
-    if '..' in filename or '/' in filename:
-        return Response(status_code=403)
-    video_path = os.path.join(WALL_VIDEO_DIR, filename)
-    if not os.path.exists(video_path):
-        return Response(status_code=404)
-    ext = os.path.splitext(filename)[1].lower()
-    media_type = 'video/mp4' if ext == '.mp4' else 'video/webm'
-    return FileResponse(video_path, media_type=media_type)
-
-@app.delete('/api/wall/{post_id}')
-def api_wall_delete(post_id: str):
-    posts = _load_wall_posts()
-    if not isinstance(posts, list):
-        return JSONResponse({"error": "No posts"}, status_code=404)
-    for i, p in enumerate(posts):
-        if p.get('id') == post_id:
-            if p.get('video'):
-                video_name = p['video'].split('/')[-1]
-                video_path = os.path.join(WALL_VIDEO_DIR, video_name)
-                if os.path.exists(video_path):
-                    os.remove(video_path)
-            posts.pop(i)
-            _save_wall_posts(posts)
-            return JSONResponse({"ok": True})
-    return JSONResponse({"error": "Post not found"}, status_code=404)
-
-# ===== LANGUAGE & EMOTION DETECTION =====
-import random as _random2
-from urllib.parse import quote as _quote2
-
-_UA_RW = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36', 'Accept-Language': 'vi-VN,vi;q=0.9'}
-
-# Unique character markers for language detection
-_UNIQUE_CHARS = {
-    'vietnamese': set('đăâêôơưàảãạáằẳẵặắầẩẫậấèẻẽẹé��ễểệếìỉĩịíòỏõọóồổỗộốờởỡợớùủũụúừửữựứỳỷỹỵý'),
-    'spanish': set('ñáéíóúü¿¡'),
-    'portuguese': set('ãõçáéíóúâêôà'),
-}
-
-_STOPWORDS = {
-    'english': {'the', 'is', 'at', 'which', 'on', 'a', 'an', 'and', 'or', 'but', 'in', 'with', 'to', 'for', 'of', 'not', 'no', 'can', 'had', 'have', 'has', 'was', 'were', 'are', 'be', 'been', 'this', 'that', 'it', 'he', 'she', 'they', 'his', 'her', 'my', 'your', 'our', 'we', 'you', 'i'},
-    'vietnamese': {'là', 'của', 'và', 'có', 'được', 'cho', 'không', 'với', 'này', 'đó', 'từ', 'trong', 'đã', 'sẽ', 'một', 'các', 'những', 'về', 'tại', 'người', 'năm', 'đến', 'ra', 'lại', 'như', 'khi', 'để', 'rất', 'cũng', 'mà', 'nếu', 'sau', 'trên', 'theo', 'vì', 'do', 'nên', 'thì', 'mình', 'tôi', 'bạn', 'anh', 'chị', 'em'},
-    'portuguese': {'de', 'um', 'que', 'e', 'do', 'da', 'em', 'para', 'com', 'não', 'uma', 'os', 'no', 'se', 'na', 'por', 'mais', 'as', 'dos', 'como', 'mas', 'ao', 'ele', 'das', 'tem', 'seu', 'sua', 'ou', 'quando', 'muito', 'nos', 'já', 'eu', 'também', 'só', 'pelo', 'pela', 'até', 'isso', 'ela', 'entre', 'depois', 'sem', 'mesmo', 'aos', 'são', 'está', 'ter', 'ser', 'foi', 'era', 'há', 'estão', 'você', 'nós', 'eles', 'elas'},
-    'spanish': {'de', 'que', 'el', 'en', 'y', 'a', 'los', 'del', 'se', 'las', 'por', 'un', 'para', 'con', 'no', 'una', 'su', 'al', 'es', 'lo', 'como', 'más', 'pero', 'sus', 'le', 'ya', 'o', 'fue', 'este', 'ha', 'si', 'porque', 'esta', 'son', 'entre', 'está', 'cuando', 'muy', 'sin', 'sobre', 'ser', 'también', 'me', 'hasta', 'hay', 'donde', 'han', 'quien', 'están', 'desde', 'todo', 'nos', 'durante', 'todos', 'uno', 'les', 'ni', 'contra', 'otros', 'fueron', 'ese', 'eso', 'ante', 'ellos', 'yo', 'tú', 'él', 'ella', 'nosotros', 'usted', 'ustedes'},
-}
-
-def detect_language(text):
-    """Detect language from text content using stopword + character analysis."""
-    if not text:
-        return 'vietnamese'
-    text_lower = text.lower()
-    text_chars = set(text_lower)
-    
-    # Strong signal: Vietnamese unique characters
-    vn_chars = len(text_chars & _UNIQUE_CHARS['vietnamese'])
-    if vn_chars >= 2:
-        return 'vietnamese'
-    
-    # Spanish unique chars (ñ, ¿, ¡)
-    es_chars = len(text_chars & _UNIQUE_CHARS['spanish'])
-    pt_chars = len(text_chars & _UNIQUE_CHARS['portuguese'])
-    
-    # Stopword scoring
-    words = set(re.findall(r'\b\w+\b', text_lower))
-    scores = {}
-    for lang, stops in _STOPWORDS.items():
-        scores[lang] = len(words & stops) / max(len(stops), 1)
-    
-    # Disambiguate Portuguese vs Spanish
-    pt_markers = {'não', 'pelo', 'pela', 'isso', 'há', 'estão', 'num', 'numa', 'tenho', 'posso', 'você', 'nós', 'eles', 'elas', 'também', 'muito', 'já', 'só', 'até', 'entre', 'depois', 'sem', 'mesmo', 'aos', 'serão'}
-    es_markers = {'pero', 'está', 'están', 'porque', 'también', 'hasta', 'donde', 'quien', 'fue', 'son', 'fueron', 'ese', 'eso', 'ante', 'ellos', 'ella', 'nosotros', 'usted', 'ustedes', 'tú', 'él', 'desde', 'todo', 'durante', 'todos', 'uno', 'les', 'ni', 'contra', 'otros', 'fueron'}
-    
-    pt_overlap = len(words & pt_markers)
-    es_overlap = len(words & es_markers)
-    
-    if scores.get('portuguese', 0) > 0 and pt_overlap > es_overlap:
-        return 'portuguese'
-    if scores.get('spanish', 0) > 0 and es_overlap > pt_overlap:
-        return 'spanish'
-    if scores.get('english', 0) > 0.15:
-        return 'english'
-    
-    best = max(scores, key=scores.get)
-    return best if scores[best] > 0.05 else 'vietnamese'
-
-# Emotion keyword-based detection
-_EMOTION_KEYWORDS = {
-    'happy': {
-        'en': ['happy', 'joy', 'wonderful', 'great', 'amazing', 'fantastic', 'love', 'excellent', 'beautiful', 'glad', 'delighted', 'pleased', 'cheerful', 'celebrate', 'victory', 'win', 'success'],
-        'pt': ['feliz', 'alegria', 'maravilhoso', 'ótimo', 'incrível', 'fantástico', 'amor', 'excelente', 'lindo', 'contente', 'encantado', 'vitória', 'sucesso'],
-        'es': ['feliz', 'alegria', 'maravilloso', 'genial', 'increíble', 'fantástico', 'amor', 'excelente', 'hermoso', 'contento', 'encantado', 'victoria', 'éxito'],
-        'vi': ['vui', 'hạnh phúc', 'tuyệt vời', 'tuyệt', 'ý nghĩa', 'đẹp', 'thích', 'yêu', 'vui vẻ', 'hân hoan', 'phấn khích', 'chiến thắng', 'thành công'],
-    },
-    'sad': {
-        'en': ['sad', 'unhappy', 'terrible', 'awful', 'horrible', 'miserable', 'depressed', 'grief', 'sorrow', 'tragic', 'unfortunate', 'painful', 'death', 'die', 'kill'],
-        'pt': ['triste', 'infeliz', 'terrível', 'horrível', 'miserável', 'deprimido', 'dor', 'trágico', 'infelizmente', 'penoso', 'morte', 'morrer'],
-        'es': ['triste', 'infeliz', 'terrible', 'horrible', 'miserable', 'deprimido', 'dolor', 'trágico', 'desafortunado', 'penoso', 'muerte', 'morir'],
-        'vi': ['buồn', 'không vui', 'tồi tệ', 'kinh khủng', 'đau khổ', 'đau buồn', 'bi thương', 'kh���n nạn', 'đau đớn', 'thảm họa', 'chết', 'mất'],
-    },
-    'excited': {
-        'en': ['excited', 'thrilling', 'amazing', 'wow', 'incredible', 'unbelievable', 'awesome', 'exhilarating', 'electrifying', 'breathtaking', 'breakthrough', 'record'],
-        'pt': ['animado', 'emocionante', 'incrível', 'impressionante', 'sensacional', 'eletrizante', 'empolgante', 'recorde'],
-        'es': ['emocionante', 'increíble', 'impresionante', 'sensacional', 'electrizante', 'emocionado', 'entusiasmado', 'récord'],
-        'vi': ['hào hứng', 'phấn khích', 'thú vị', 'tuyệt cú mèo', 'đỉnh cao', 'ngoạn mục', 'sục sôi', 'kỷ lục', 'đột phá'],
-    },
-    'humorous': {
-        'en': ['funny', 'hilarious', 'joke', 'laugh', 'comedy', 'humor', 'amusing', 'witty', 'sarcastic', 'ironic', 'ridiculous', 'absurd', 'lol', 'haha'],
-        'pt': ['engraçado', 'hilário', 'piada', 'rir', 'comédia', 'humor', 'divertido', 'irônico', 'ridículo', 'absurdo', 'kkk'],
-        'es': ['gracioso', 'hilarante', 'broma', 'risa', 'comedia', 'humor', 'divertido', 'irónico', 'ridículo', 'absurdo', 'jaja'],
-        'vi': ['hài hước', 'buồn cười', 'đùa', 'cười', 'hài', 'vui nhộn', 'hóm hỉnh', 'mỉa mai', 'lố bịch', 'vô lý', 'haha'],
-    },
-    'serious': {
-        'en': ['serious', 'critical', 'important', 'urgent', 'severe', 'grave', 'significant', 'crucial', 'vital', 'essential', 'alarming', 'concerning', 'crisis', 'war', 'conflict'],
-        'pt': ['sério', 'crítico', 'importante', 'urgente', 'grave', 'significativo', 'crucial', 'vital', 'essencial', 'preocupante', 'crise', 'guerra', 'conflito'],
-        'es': ['serio', 'crítico', 'importante', 'urgente', 'grave', 'significativo', 'crucial', 'vital', 'esencial', 'preocupante', 'crisis', 'guerra', 'conflicto'],
-        'vi': ['nghiêm trọng', 'quan trọng', 'khẩn cấp', 'nghiêm túc', 'đáng kể', 'thiết yếu', 'cần thiết', 'báo động', 'lo ngại', 'khủng hoảng', 'chiến tranh', 'xung đột'],
-    },
-}
-
-def detect_emotion(text, language='vietnamese'):
-    """Detect emotion from text using keyword matching."""
-    if not text:
-        return 'neutral'
-    text_lower = text.lower()
-    
-    scores = {}
-    for emotion, lang_keywords in _EMOTION_KEYWORDS.items():
-        keywords = lang_keywords.get(language, lang_keywords.get('en', []))
-        score = sum(1 for kw in keywords if kw in text_lower)
-        scores[emotion] = score
-    
-    if max(scores.values()) == 0:
-        return 'neutral'
-    
-    return max(scores, key=scores.get)
-
-def detect_language_and_emotion(title, text):
-    """Detect both language and emotion from article content."""
-    combined = f"{title} {text}"
-    lang = detect_language(combined)
-    emotion = detect_emotion(combined, lang)
-    return lang, emotion
-
-# Voice selection based on language and emotion (using MultilingualNeural voices)
-VOICE_BY_LANG_EMOTION = {
-    'vietnamese': {
-        'happy': ('vi-VN-HoaiMyNeural', 'vui'),
-        'sad': ('vi-VN-NamMinhNeural', 'buồn'),
-        'excited': ('vi-VN-HoaiMyNeural', 'hào hứng'),
-        'humorous': ('vi-VN-HoaiMyNeural', 'vui'),
-        'serious': ('vi-VN-NamMinhNeural', 'nghiêm túc'),
-        'neutral': ('vi-VN-HoaiMyNeural', 'trung_tinh'),
-    },
-    'portuguese': {
-        'happy': ('pt-BR-ThalitaMultilingualNeural', 'feliz'),
-        'sad': ('pt-BR-ThalitaMultilingualNeural', 'triste'),
-        'excited': ('pt-BR-ThalitaMultilingualNeural', 'animado'),
-        'humorous': ('pt-BR-ThalitaMultilingualNeural', 'engraçado'),
-        'serious': ('pt-BR-ThalitaMultilingualNeural', 'sério'),
-        'neutral': ('pt-BR-ThalitaMultilingualNeural', 'neutro'),
-    },
-    'english': {
-        'happy': ('en-US-AndrewMultilingualNeural', 'happy'),
-        'sad': ('en-AU-WilliamMultilingualNeural', 'sad'),
-        'excited': ('en-US-AndrewMultilingualNeural', 'excited'),
-        'humorous': ('en-US-AndrewMultilingualNeural', 'funny'),
-        'serious': ('en-AU-WilliamMultilingualNeural', 'serious'),
-        'neutral': ('en-US-AndrewMultilingualNeural', 'neutral'),
-    },
-    'french': {
-        'happy': ('fr-FR-VivienneMultilingualNeural', 'heureux'),
-        'sad': ('fr-FR-RemyMultilingualNeural', 'triste'),
-        'excited': ('fr-FR-VivienneMultilingualNeural', 'excité'),
-        'humorous': ('fr-FR-VivienneMultilingualNeural', 'drôle'),
-        'serious': ('fr-FR-RemyMultilingualNeural', 'sérieux'),
-        'neutral': ('fr-FR-VivienneMultilingualNeural', 'neutre'),
-    },
-    'german': {
-        'happy': ('de-DE-SeraphinaMultilingualNeural', 'glücklich'),
-        'sad': ('de-DE-FlorianMultilingualNeural', 'traurig'),
-        'excited': ('de-DE-SeraphinaMultilingualNeural', 'aufgeregt'),
-        'humorous': ('de-DE-SeraphinaMultilingualNeural', 'lustig'),
-        'serious': ('de-DE-FlorianMultilingualNeural', 'ernst'),
-        'neutral': ('de-DE-SeraphinaMultilingualNeural', 'neutral'),
-    },
-    'korean': {
-        'happy': ('ko-KR-HyunsuMultilingualNeural', '행복'),
-        'sad': ('ko-KR-HyunsuMultilingualNeural', '슬픔'),
-        'excited': ('ko-KR-HyunsuMultilingualNeural', '흥분'),
-        'humorous': ('ko-KR-HyunsuMultilingualNeural', '유쾌'),
-        'serious': ('ko-KR-HyunsuMultilingualNeural', '진지'),
-        'neutral': ('ko-KR-HyunsuMultilingualNeural', '중립'),
-    },
-    'italian': {
-        'happy': ('it-IT-GiuseppeMultilingualNeural', 'felice'),
-        'sad': ('it-IT-GiuseppeMultilingualNeural', 'triste'),
-        'excited': ('it-IT-GiuseppeMultilingualNeural', 'emozionato'),
-        'humorous': ('it-IT-GiuseppeMultilingualNeural', 'divertente'),
-        'serious': ('it-IT-GiuseppeMultilingualNeural', 'serio'),
-        'neutral': ('it-IT-GiuseppeMultilingualNeural', 'neutro'),
-    },
-}
-
-# All valid voice IDs (new MultilingualNeural format)
-VALID_VOICES = {
-    'vi-VN-HoaiMyNeural', 'vi-VN-NamMinhNeural',
-    'en-US-AndrewMultilingualNeural', 'en-AU-WilliamMultilingualNeural',
-    'pt-BR-ThalitaMultilingualNeural',
-    'fr-FR-VivienneMultilingualNeural', 'fr-FR-RemyMultilingualNeural',
-    'de-DE-SeraphinaMultilingualNeural', 'de-DE-FlorianMultilingualNeural',
-    'ko-KR-HyunsuMultilingualNeural',
-    'it-IT-GiuseppeMultilingualNeural',
-}
-
-def get_voice_for_content(title, text, preferred_voice=None):
-    """Get appropriate voice based on content language and emotion."""
-    # Accept the new MultilingualNeural voices directly
-    if preferred_voice and preferred_voice in VALID_VOICES:
-        return preferred_voice
-    
-    # Also accept old shorthand voice IDs and map them to new format
-    old_voice_map = {
-        'hoaimy': 'vi-VN-HoaiMyNeural',
-        'namminh': 'vi-VN-NamMinhNeural',
-        'andrew': 'en-US-AndrewMultilingualNeural',
-        'jenny': 'en-US-AndrewMultilingualNeural',
-        'thalita': 'pt-BR-ThalitaMultilingualNeural',
-        'pt_thalita': 'pt-BR-ThalitaMultilingualNeural',
-        'pt_francisco': 'pt-BR-ThalitaMultilingualNeural',
-        'ela': 'en-US-AndrewMultilingualNeural',
-        'es_carlos': 'en-US-AndrewMultilingualNeural',
-        'denise': 'fr-FR-VivienneMultilingualNeural',
-        'katja': 'de-DE-SeraphinaMultilingualNeural',
-        'nanami': 'en-US-AndrewMultilingualNeural',
-        'sunhee': 'ko-KR-HyunsuMultilingualNeural',
-        'xiaochen': 'en-US-AndrewMultilingualNeural',
-    }
-    if preferred_voice and preferred_voice in old_voice_map:
-        return old_voice_map[preferred_voice]
-    
-    lang, emotion = detect_language_and_emotion(title, text)
-    lang_map = VOICE_BY_LANG_EMOTION.get(lang, VOICE_BY_LANG_EMOTION['vietnamese'])
-    voice, _ = lang_map.get(emotion, lang_map['neutral'])
-    return voice
-
-
-def _is_relevant_image(img_url, title, text):
-    """Check if an image is relevant to the article content."""
-    if not img_url:
-        return False
-    skip_patterns = ['pixel', 'analytics', 'tracking', '1x1.gif', 'spacer.gif',
-                     'logo', 'icon', 'avatar', 'emoji', 'smiley', 'sprite',
-                     'advertisement', 'ad-banner', 'sponsored', 'banner-ads']
-    img_lower = img_url.lower()
-    for p in skip_patterns:
-        if p in img_lower:
-            return False
-    if not any(img_lower.endswith(ext) for ext in ['.jpg', '.jpeg', '.png', '.webp', '.gif']):
-        return False
-    return True
-
-
-def _filter_relevant_images(images, title, text, max_images=8):
-    """Filter and rank images by relevance to article content."""
-    if not images:
-        return []
-    seen = set()
-    relevant = []
-    for img in images:
-        if img in seen:
-            continue
-        seen.add(img)
-        if _is_relevant_image(img, title, text):
-            relevant.append(img)
-    return relevant[:max_images]
-
-
-def _scrape_article_for_rewrite(url):
-    """Scrape article: extract title, paragraphs, RELEVANT images, OG image."""
-    try:
-        r = req.get(url, headers=_UA_RW, timeout=15, allow_redirects=True)
-        r.encoding = 'utf-8'
-        soup = BeautifulSoup(r.text, 'lxml')
-        for tag in soup.find_all(['script', 'style', 'nav', 'footer', 'aside', 'form']):
-            tag.decompose()
-        h1 = soup.find('h1')
-        ogt = soup.find('meta', property='og:title')
-        title = (h1.get_text(strip=True) if h1 else '') or (ogt.get('content', '') if ogt else '')
-        ogi = soup.find('meta', property='og:image')
-        og_img = ogi.get('content', '') if ogi else ''
-        if og_img and og_img.startswith('//'):
-            og_img = 'https:' + og_img
-        block = None
-        for sel in ['article', '.singular-content', '.detail-content', '.fck_detail', '.content-detail', '.knc-content', 'main', '.cms-body', '.article__body']:
-            el = soup.select_one(sel)
-            if el and len(el.find_all('p')) >= 2:
-                block = el
-                break
-        if not block:
-            block = soup.body or soup
-        paragraphs = []
-        all_images = []
-        seen_imgs = set()
-        if og_img and og_img not in seen_imgs:
-            all_images.append(og_img)
-            seen_imgs.add(og_img)
-        for el in block.find_all(['p', 'h2', 'h3', 'figure', 'img'], recursive=True):
-            if el.name == 'p':
-                t = _clean(el.get_text(strip=True))
-                if t and len(t) > 40:
-                    paragraphs.append(t)
-            elif el.name in ('figure', 'img'):
-                im = el if el.name == 'img' else el.find('img')
-                if im:
-                    src = im.get('data-src') or im.get('src') or im.get('data-original') or ''
-                    if src and 'base64' not in src:
-                        if src.startswith('//'):
-                            src = 'https:' + src
-                        if src not in seen_imgs:
-                            all_images.append(src)
-                            seen_imgs.add(src)
-        # Filter to relevant images only
-        relevant_images = _filter_relevant_images(all_images, title, ' '.join(paragraphs[:5]))
-        return {'title': _clean(title), 'paragraphs': paragraphs, 'images': relevant_images, 'og_img': og_img}
-    except Exception:
-        return None
-
-
-def _extract_key_points_rw(paragraphs, max_points=5):
-    r"""Extract key points from paragraphs - extracts ALL sentences, not just first one.
-    
-    Fixes: Original regex `^(.+?[.!?])\s` only captured first sentence per paragraph.
-    Now splits on all sentence boundaries and takes valid sentences until max_points.
-    """
-    points = []
-    
-    for p in paragraphs:
-        if len(points) >= max_points:
-            break
-        
-        p = _clean(p)
-        if not p:
-            continue
-        
-        # Split paragraph into sentences using Vietnamese + English punctuation
-        sentences = re.split(r'(?<=[.!?])\s+(?=[A-ZÀ-Ỹ0-9])', p)
-        sentences = [s.strip() for s in sentences if s.strip()]
-        
-        for sentence in sentences:
-            if len(points) >= max_points:
-                break
-            
-            # Clean sentence - remove extra whitespace
-            sentence = _clean(sentence)
-            
-            if len(sentence) < 30:
-                continue
-            
-            # Check for duplicates
-            if any(sentence[:60] in existing for existing in points):
-                continue
-            
-            # Ensure sentence ends with punctuation
-            if not sentence.endswith(('.', '!', '?')):
-                sentence = sentence + '.'
-            
-            points.append(sentence)
-    
-    # If no valid sentences found, take chunks from raw text
-    if not points:
-        raw = '\n'.join(paragraphs)
-        for i in range(0, min(len(raw), max_points * 300), 280):
-            chunk = _clean(raw[i:i+280])
-            if len(chunk) >= 30 and chunk not in points:
-                points.append(chunk + ('.' if not chunk.endswith('.') else ''))
-            if len(points) >= max_points:
-                break
-    
-    return points
-
-
-@app.post("/api/rewrite_slide")
-async def api_rewrite_slide(request: Request):
-    """Fast rewrite as SLIDES - no AI needed, instant response."""
-    body = await request.json()
-    url = _clean(body.get("url", ""))
-    context = body.get("context", "")
-    preferred_voice = body.get("voice", "")  # Accept custom voice selection
-    if not url and not context:
-        return JSONResponse({"error": "Cần URL hoặc nội dung"}, status_code=400)
-    data = None
-    if url and url.startswith("http"):
-        data = _scrape_article_for_rewrite(url)
-    if not data and context:
-        paragraphs = [_clean(p) for p in context.split('\n') if len(_clean(p)) > 40]
-        data = {'title': paragraphs[0][:80] if paragraphs else 'Bài viết', 'paragraphs': paragraphs, 'images': [], 'og_img': ''}
-    if not data or not data.get('paragraphs'):
-        return JSONResponse({"error": "Không đọc được bài viết"}, status_code=422)
-    points = _extract_key_points_rw(data['paragraphs'], max_points=12)
-    if not points:
-        return JSONResponse({"error": "Không tìm được ý chính"}, status_code=422)
-    images = data.get('images', [])
-    slides = []
-    for i, point in enumerate(points):
-        img = images[i] if i < len(images) else (images[-1] if images else '')
-        if img and 'cdnphoto.dantri' in img:
-            img = '/api/proxy/img?url=' + _quote2(img, safe='')
-        slides.append({'text': point, 'image': img, 'index': i + 1})
-    summary_text = '\n\n'.join([f"• {s['text']}" for s in slides])
-    
-    # Auto-detect language and emotion
-    lang, emotion = detect_language_and_emotion(data['title'], summary_text)
-    # Use preferred voice if provided, otherwise auto-detect
-    voice = preferred_voice if preferred_voice else get_voice_for_content(data['title'], summary_text)
-    
-    post = {
-        "id": str(int(time.time() * 1000)) + str(_random2.randint(100, 999)),
-        "title": data['title'],
-        "text": summary_text,
-        "img": images[0] if images else '',
-        "url": url,
-        "kind": "slide_summary",
-        "slides": slides,
-        "images": images[:10],
-        "video": "",
-        "voice": voice,
-        "emotion": emotion,
-        "language": lang,
-        "ts": int(time.time())
-    }
-    posts = _load_wall_posts()
-    posts.insert(0, post)
-    _save_wall_posts(posts)
-    return JSONResponse({"post": post, "slides": slides})
-
-
-@app.post("/api/rewrite_share")
-async def api_rewrite_share(request: Request):
-    """Rewrite article and post to Tường AI with SLIDES + AI text."""
-    body = await request.json()
-    url = _clean(body.get("url", ""))
-    ctx = _clean(body.get("context", ""))
-    preferred_voice = body.get("voice", "")  # Accept custom voice selection
-    if not url and not ctx:
-        return JSONResponse({"error": "Cần URL hoặc nội dung"}, status_code=400)
-    data = None
-    if url and url.startswith("http"):
-        data = _scrape_article_for_rewrite(url)
-    if not data and ctx:
-        paragraphs = [_clean(p) for p in ctx.split('\n') if len(_clean(p)) > 40]
-        data = {'title': paragraphs[0][:80] if paragraphs else 'Bài viết', 'paragraphs': paragraphs, 'images': [], 'og_img': ''}
-    if not data or not data.get('paragraphs'):
-        return JSONResponse({"error": "Không đọc được bài viết"}, status_code=422)
-    raw_text = '\n'.join(data['paragraphs'])
-    if len(raw_text) < 50:
-        raw_text = ctx[:14000]
-    if len(raw_text) < 50:
-        return JSONResponse({"error": "Bài viết quá ngắn"}, status_code=422)
-    domain = ''
-    try:
-        from urllib.parse import urlparse
-        domain = urlparse(url).netloc.replace('www.', '')
-    except:
-        pass
-    
-    # Generate AI summary text
-    ai_text = None
-    try:
-        import ai_ext
-        if hasattr(ai_ext, 'qwen_generate'):
-            prompt = f'Tóm tắt đăng Tường AI:\nTiêu đề: {data["title"]}\n{raw_text[:14000]}\n\n4-6 ý chính. Cuối ghi nguồn.'
-            ai_text = await ai_ext.qwen_generate(prompt, max_tokens=1000)
-    except Exception:
-        pass
-    if not ai_text or len(ai_text) < 80:
-        key_pts = _extract_key_points_rw(data['paragraphs'], max_points=12)
-        if key_pts:
-            ai_text = '\n\n'.join([f"• {p}" for p in key_pts])
-        else:
-            ai_text = f"Tóm tắt: {data['title']}\n\n{raw_text[:1200]}\n\nNguồn: {domain}"
-    
-    # Build slides from key points (FIX: include slides in rewrite_share too!)
-    points = _extract_key_points_rw(data['paragraphs'], max_points=12)
-    images = data.get('images', [])
-    slides = []
-    for i, point in enumerate(points):
-        img = images[i] if i < len(images) else (images[-1] if images else '')
-        if img and 'cdnphoto.dantri' in img:
-            img = '/api/proxy/img?url=' + _quote2(img, safe='')
-        slides.append({'text': point, 'image': img, 'index': i + 1})
-    
-    # Auto-detect language and emotion
-    lang, emotion = detect_language_and_emotion(data['title'], ai_text)
-    # Use preferred voice if provided, otherwise auto-detect
-    voice = preferred_voice if preferred_voice else get_voice_for_content(data['title'], ai_text)
-    
-    post = {
-        "id": str(int(time.time() * 1000)) + str(_random2.randint(100, 999)),
-        "title": data['title'],
-        "text": ai_text,
-        "img": images[0] if images else '',
-        "url": url,
-        "kind": "rewrite",
-        "slides": slides,
-        "images": images[:10],
-        "video": "",
-        "voice": voice,
-        "emotion": emotion,
-        "language": lang,
-        "ts": int(time.time())
-    }
-    posts = _load_wall_posts()
-    posts.insert(0, post)
-    _save_wall_posts(posts)
-    return JSONResponse({"post": post, "slides": slides})
-
-
-@app.post("/api/url_wall")
-async def api_url_wall(request: Request):
-    """Submit URL to add to Tường AI."""
-    body = await request.json()
-    url = _clean(body.get("url", ""))
-    if not url or not url.startswith('http'):
-        return JSONResponse({"error": "URL không hợp lệ"}, status_code=400)
-    # Reuse rewrite_share logic
-    req._body = json.dumps({"url": url}).encode()
-    return await api_rewrite_share(request)
-
-
-# ===== PERSONAL OPINION POST v2: AI tổng hợp bài viết từ quan điểm + nguồn tin HOT =====
-@app.post("/api/personal_post/preview")
-async def api_personal_post_preview(request: Request):
-    """Preview personal post: fetch full articles, let AI compose logical article with images."""
-    body = await request.json()
-    opinion = _clean(body.get("opinion", ""))
-    selected_topics = body.get("selected_topics", []) or []
-    selected_sources = body.get("selected_sources", []) or []
-    
-    if not opinion or len(opinion) < 10:
-        return JSONResponse({"error": "Quan điểm cá nhân quá ngắn (cần ít nhất 10 ký tự)"}, status_code=400)
-    
-    # Lấy HOT topics nếu ko có selected
-    if not selected_topics:
-        hot = _get_hot_topics()
-        selected_topics = [t.get("topic", "") for t in hot[:3] if t.get("topic")]
-    
-    # Tìm nguồn tin
-    all_sources = []
-    seen_urls = set()
-    for topic in selected_topics[:3]:
-        sources = _search_all(topic, limit=5)
-        for s in sources:
-            if s.get("url") and s["url"] not in seen_urls:
-                seen_urls.add(s["url"])
-                all_sources.append(s)
-                if len(all_sources) >= 6:
-                    break
-        if len(all_sources) >= 6:
-            break
-    
-    for src in selected_sources:
-        if src.get("url") and src["url"] not in seen_urls:
-            all_sources.insert(0, src)
-    
-    # Scrape nội dung đầy đủ từng nguồn (paragraphs + images)
-    source_details = []
-    source_images = []
-    for src in all_sources[:5]:
-        url = src.get("url", "")
-        if not url:
-            continue
-        try:
-            art = _scrape_article_for_rewrite(url)
-            if art:
-                src_detail = {
-                    "title": art.get("title", src.get("title", "")),
-                    "url": url,
-                    "via": src.get("via", ""),
-                    "paragraphs": art.get("paragraphs", [])[:8],
-                    "images": art.get("images", [])[:3],
-                    "og_image": art.get("og_img", "")
-                }
-                source_details.append(src_detail)
-                # Collect images for proxy
-                for img in art.get("images", [])[:2]:
-                    if any(x in img for x in ["cdnphoto.dantri", "vnexpress", "vcdn", "refooty"]):
-                        img = "/api/proxy/img?url=" + _quote2(img, safe="")
-                    source_images.append(img)
-        except:
-            pass
-        if len(source_details) >= 5:
-            break
-    
-    # Tạo title từ opinion
-    opinion_words = re.findall(r"[A-Za-zÀ-ỹ0-9]+", opinion)
-    title_words = opinion_words[:8] if len(opinion_words) >= 8 else opinion_words[:4]
-    title = " ".join([w[0].upper() + w[1:] for w in title_words]) if title_words else "Quan điểm cá nhân"
-    title = title[:80]
-    
-    # AI sinh bài viết hoàn chỉnh
-    ai_text = None
-    try:
-        import ai_ext
-        if hasattr(ai_ext, 'qwen_generate'):
-            # Build detailed context from source articles
-            source_context = ""
-            for i, sd in enumerate(source_details[:5]):
-                src_title = sd.get("title", "")
-                src_via = sd.get("via", "")
-                src_paras = sd.get("paragraphs", [])
-                source_context += f"\n=== Nguồn {i+1}: {src_title} ({src_via}) ===\n"
-                for j, p in enumerate(src_paras[:4]):
-                    source_context += f"  - {p[:300]}\n"
-            
-            prompt = (
-                "Bạn là nhà báo chuyên nghiệp tiếng Việt. Hãy viết một bài phân tích dựa trên quan điểm cá nhân và các nguồn tin sau đây.\n\n"
-                "=== QUAN ĐIỂM CÁ NHÂN ===\n" + opinion[:2000] + "\n\n"
-                "=== NGUỒN TIN THAM KHẢO (kèm nội dung chi tiết) ===\n" + source_context + "\n\n"
-                "=== YÊU CẦU BÀI VIẾT ===\n"
-                "1. Mở đầu: Giới thiệu chủ đề và nêu quan điểm cá nhân (1-2 câu)\n"
-                "2. Thân bài: Phân tích luận điểm, dùng dẫn chứng CỤ THỂ từ nguồn tin (trích dẫn nguồn kèm tên báo)\n"
-                "3. Mỗi luận điểm là 1 đoạn ngắn 2-4 câu, có ghi nguồn rõ ràng (VD: Theo VnExpress, ...)\n"
-                "4. Kết luận: Tổng kết quan điểm, gợi mở suy nghĩ\n"
-                "5. Cuối bài: Ghi danh sách nguồn tham khảo\n\n"
-                "Viết tự nhiên, mạch lạc, giọng văn báo chí - phân tích. Độ dài: 300-600 từ."
-            )
-            ai_text = await ai_ext.qwen_generate(prompt, max_tokens=2000)
-    except:
-        pass
-    
-    if not ai_text or len(ai_text) < 100:
-        # Fallback: build article manually
-        ai_text = "## " + title + "\n\n"
-        ai_text += opinion + "\n\n"
-        for i, sd in enumerate(source_details[:5]):
-            ai_text += "### " + sd.get("title", f"Nguồn {i+1}") + "\n"
-            for p in sd.get("paragraphs", [])[:3]:
-                ai_text += p[:250] + "\n"
-            ai_text += "*Nguồn: " + sd.get("via", "") + "*\n\n"
-        ai_text += "\n---\n*Bài viết tổng hợp từ quan điểm cá nhân và các nguồn tin liên quan*"
-    
-    # Tạo slides từ bài viết
-    slide_parts = []
-    if ai_text:
-        paragraphs = [p.strip() for p in ai_text.split("\n") if p.strip() and len(p.strip()) > 40]
-        current_para = ""
-        para_count = 0
-        for p in paragraphs:
-            if p.startswith("## ") or p.startswith("### ") or p.startswith("---"):
-                if current_para and para_count < 6:
-                    slide_parts.append(current_para)
-                    para_count += 1
-                current_para = ""
-            elif not p.startswith("*") and not p.startswith("- "):
-                if len(p) > 80:
-                    if current_para:
-                        current_para += "\n\n" + p
-                    else:
-                        current_para = p
-        if current_para and para_count < 6:
-            slide_parts.append(current_para)
-    
-    if len(slide_parts) < 2:
-        # Create slides from opinion + sources
-        slide_parts = [opinion[:300]]
-        for sd in source_details[:4]:
-            slide_parts.append(sd.get("title", "")[:200] + "\n\n" + (sd.get("paragraphs", [""])[0][:200] if sd.get("paragraphs") else ""))
-    
-    slides = []
-    total = min(len(slide_parts), 6)
-    for i in range(total):
-        img = source_images[i] if i < len(source_images) else ""
-        slides.append({
-            "text": slide_parts[i],
-            "image": img,
-            "index": i + 1
-        })
-    
-    preview = {
-        "title": title,
-        "text": ai_text,
-        "opinion": opinion,
-        "images": source_images[:10],
-        "sources": source_details[:5],
-        "slides": slides
-    }
-    
-    return JSONResponse({"preview": preview})
-
-
-@app.post("/api/personal_post")
-async def api_personal_post(request: Request):
-    """Create and save personal opinion post."""
-    body = await request.json()
-    opinion = _clean(body.get("opinion", ""))
-    selected_topics = body.get("selected_topics", []) or []
-    selected_sources = body.get("selected_sources", []) or []
-    custom_title = body.get("custom_title", "")
-    custom_slides = body.get("custom_slides", [])
-    
-    if not opinion or len(opinion) < 10:
-        return JSONResponse({"error": "Quan điểm cá nhân quá ngắn (cần ít nhất 10 ký tự)"}, status_code=400)
-    
-    if not selected_topics:
-        hot = _get_hot_topics()
-        selected_topics = [t.get("topic", "") for t in hot[:3] if t.get("topic")]
-    
-    all_sources = []
-    seen_urls = set()
-    for topic in selected_topics[:3]:
-        sources = _search_all(topic, limit=5)
-        for s in sources:
-            if s.get("url") and s["url"] not in seen_urls:
-                seen_urls.add(s["url"])
-                all_sources.append(s)
-                if len(all_sources) >= 6:
-                    break
-        if len(all_sources) >= 6:
-            break
-    
-    for src in selected_sources:
-        if src.get("url") and src["url"] not in seen_urls:
-            all_sources.insert(0, src)
-    
-    source_details = []
-    source_images = []
-    for src in all_sources[:5]:
-        url = src.get("url", "")
-        if not url:
-            continue
-        try:
-            art = _scrape_article_for_rewrite(url)
-            if art:
-                src_detail = {
-                    "title": art.get("title", src.get("title", "")),
-                    "url": url,
-                    "via": src.get("via", ""),
-                    "paragraphs": art.get("paragraphs", [])[:6],
-                    "images": art.get("images", [])[:2],
-                    "og_image": art.get("og_img", "")
-                }
-                source_details.append(src_detail)
-                for img in art.get("images", [])[:2]:
-                    if any(x in img for x in ["cdnphoto.dantri", "vnexpress", "vcdn", "refooty"]):
-                        img = "/api/proxy/img?url=" + _quote2(img, safe="")
-                    source_images.append(img)
-        except:
-            pass
-    
-    # Title
-    if custom_title:
-        title = custom_title[:80]
-    else:
-        opinion_words = re.findall(r"[A-Za-zÀ-ỹ0-9]+", opinion)
-        title_words = opinion_words[:8] if len(opinion_words) >= 8 else opinion_words[:4]
-        title = " ".join([w[0].upper() + w[1:] for w in title_words]) if title_words else "Quan điểm cá nhân"
-        title = title[:80]
-    
-    # AI sinh bài
-    ai_text = None
-    try:
-        import ai_ext
-        if hasattr(ai_ext, 'qwen_generate'):
-            source_context = ""
-            for i, sd in enumerate(source_details[:5]):
-                src_title = sd.get("title", "")
-                src_via = sd.get("via", "")
-                src_paras = sd.get("paragraphs", [])
-                source_context += f"\nNguồn {i+1}: {src_title} ({src_via})\n"
-                for j, p in enumerate(src_paras[:3]):
-                    source_context += f"  - {p[:300]}\n"
-            prompt = (
-                "Bạn là nhà báo tiếng Việt. Viết bài phân tích dựa trên quan điểm cá nhân và các nguồn tin sau.\n\n"
-                "=== QUAN ĐIỂM ===\n" + opinion[:2000] + "\n\n"
-                "=== NGUỒN TIN ===\n" + source_context + "\n\n"
-                "Yêu cầu:\n- Mở đầu: giới thiệu chủ đề + nêu quan điểm\n- Thân bài: phân tích có dẫn chứng từ nguồn (ghi rõ nguồn)\n- Mỗi đoạn 2-4 câu\n- Kết luận: tổng kết\n- Cuối: danh sách nguồn\n\nViết tự nhiên, 300-600 từ."
-            )
-            ai_text = await ai_ext.qwen_generate(prompt, max_tokens=2000)
-    except:
-        pass
-    
-    if not ai_text or len(ai_text) < 100:
-        ai_text = "## " + title + "\n\n" + opinion + "\n\n"
-        for i, sd in enumerate(source_details[:5]):
-            ai_text += "### " + sd.get("title", "") + "\n"
-            for p in sd.get("paragraphs", [])[:2]:
-                ai_text += p[:250] + "\n"
-            ai_text += "\n---\n*Nguồn: " + sd.get("via", "") + "*\n\n"
-    
-    # Tạo slides
-    if custom_slides and len(custom_slides) > 0:
-        slides = []
-        for i, slide in enumerate(custom_slides):
-            slides.append({
-                "text": slide.get("text", ""),
-                "image": slide.get("image", ""),
-                "index": i + 1
-            })
-    else:
-        slide_parts = []
-        if ai_text:
-            paragraphs = [p.strip() for p in ai_text.split("\n") if p.strip() and len(p.strip()) > 40]
-            current = ""
-            count = 0
-            for p in paragraphs:
-                if p.startswith("## ") or p.startswith("### ") or p.startswith("---"):
-                    if current and count < 6:
-                        slide_parts.append(current)
-                        count += 1
-                    current = ""
-                elif len(p) > 80:
-                    if current:
-                        current += "\n\n" + p
-                    else:
-                        current = p
-            if current and count < 6:
-                slide_parts.append(current)
-        
-        if len(slide_parts) < 2:
-            slide_parts = [opinion[:300]]
-            for sd in source_details[:5]:
-                slide_parts.append(sd.get("title", "")[:200] + "\n" + (sd.get("paragraphs", [""])[0][:200] if sd.get("paragraphs") else ""))
-        
-        slides = []
-        total = min(len(slide_parts), 6)
-        for i in range(total):
-            img = source_images[i] if i < len(source_images) else ""
-            slides.append({
-                "text": slide_parts[i],
-                "image": img,
-                "index": i + 1
-            })
-    
-    lang, emotion = detect_language_and_emotion(title, ai_text)
-    voice = get_voice_for_content(title, ai_text)
-    
-    post = {
-        "id": str(int(time.time() * 1000)) + str(_random2.randint(100, 999)),
-        "title": title,
-        "text": ai_text,
-        "img": source_images[0] if source_images else "",
-        "url": "",
-        "kind": "personal_opinion",
-        "slides": slides,
-        "images": source_images[:10],
-        "video": "",
-        "voice": voice,
-        "emotion": emotion,
-        "language": lang,
-        "ts": int(time.time()),
-        "sources": source_details[:5]
-    }
-    
-    posts = _load_wall_posts()
-    posts.insert(0, post)
-    _save_wall_posts(posts)
-    
-    return JSONResponse({"post": post, "slides": slides})
-
-
-# ===== END PERSONAL OPINION POST v2 =====
-
-def _bg():
-    time.sleep(15)
-    while True:
-        try:get_wc2026_all()
-        except:pass
-        time.sleep(90)
-threading.Thread(target=_bg,daemon=True).start()
-
-# ===== AUTO SCHEDULER: rewrite AI + short at 7/13/19 VN time =====
-_AUTO_SCHEDULE_TIMES = [(7, '07:00'), (13, '13:00'), (19, '19:00')]
-_AUTO_LOG = os.path.join(DATA_DIR, 'auto_rewrite_log.json')
-
-def _load_auto_log():
-    try:
-        if os.path.exists(_AUTO_LOG):
-            with open(_AUTO_LOG, 'r') as f:
-                return json.load(f)
-    except: pass
-    return {}
-
-def _save_auto_log(log):
-    try:
-        tmp = _AUTO_LOG + '.tmp'
-        with open(tmp, 'w') as f:
-            json.dump(log, f)
-        os.replace(tmp, _AUTO_LOG)
-    except: pass
-
-async def _auto_fetch_short(post_id):
-    """Try to auto-generate a short for a post."""
-    try:
-        import httpx
-        async with httpx.AsyncClient(timeout=180) as cl:
-            r = await cl.post(
-                f"http://localhost:7860/api/ai/short/{post_id}",
-                json={"voice":"vi-VN-HoaiMyNeural","emotion":"neutral","speed":1.2},
-                headers={"Content-Type":"application/json"}
-            )
-            if r.status_code < 300:
-                sj = r.json()
-                if sj.get('video'):
-                    posts = _load_wall_posts()
-                    for p in posts:
-                        if p.get('id') == post_id:
-                            p['video'] = sj['video']
-                            break
-                    _save_wall_posts(posts)
-                    return True
-    except: pass
-    return False
-
-async def _auto_rewrite_one(topic, slot_label, used_urls=None, post_index=0):
-    """Rewrite one topic: find articles, summarize, post to wall, trigger short.
-    used_urls: shared set to avoid duplicate articles across topics.
-    post_index: 0-based index to create multiple posts per topic (0,1,2 = up to 3 posts)."""
-    from urllib.parse import quote as _q
-    # Get MORE items to support 1-3 posts per topic
-    items = _search_all(topic, limit=12)
-    # Skip URLs already used by another topic
-    if used_urls is not None:
-        filtered = [it for it in items if it.get('url') not in used_urls]
-        if filtered:
-            items = filtered
-    if not items or post_index >= len(items):
-        return False
-    
-    # Get article at post_index (0,1,2 for multiple posts)
-    item = items[post_index]  # post_index allows multiple articles per topic
-    url = item.get('url', '')
-    title = item.get('title', topic)
-    if url and used_urls is not None:
-        used_urls.add(url)
-    if not url.startswith('http'):
-        return False
-    
-    data = _scrape_article_for_rewrite(url)
-    if not data or not data.get('paragraphs'):
-        return False
-    
-    raw_text = '\n'.join(data['paragraphs'])
-    ai_text = None
-    
-    # Try AI generation
-    try:
-        import ai_ext
-        prompt = f"Tóm tắt tin tức (tự động {slot_label}):\nTiêu đề: {data['title']}\n{raw_text[:10000]}\n\n4-6 ý chính dạng bullet. Cuối ghi nguồn."
-        ai_text = await ai_ext.qwen_generate(prompt, max_tokens=1000)
-    except: pass
-    
-    if not ai_text or len(ai_text) < 80:
-        pts = data['paragraphs'][:6]
-        ai_text = '\n\n'.join([f"• {p[:300]}" for p in pts])
-        via = item.get('via', '') or urlparse(url).netloc.replace('www.', '')
-        ai_text += f"\n\nNguồn tham khảo: {via}"
-    
-    # Build slides
-    images = data.get('images', [])
-    pts = data['paragraphs'][:10]
-    slides = []
-    for i, p in enumerate(pts[:8]):
-        img = images[i] if i < len(images) else (images[-1] if images else data.get('og_img', ''))
-        slides.append({'text': p[:300], 'image': img, 'index': i + 1})
-    
-    post_id = str(int(time.time() * 1000)) + str(_random2.randint(100, 999))
-    post = {
-        "id": post_id, "title": data.get('title', title)[:200],
-        "text": ai_text, "img": images[0] if images else data.get('og_img', ''),
-        "url": url, "kind": "auto_rewrite", "slides": slides,
-        "images": images[:10], "video": "",
-        "voice": "vi-VN-HoaiMyNeural", "emotion": "neutral",
-        "language": "vietnamese", "ts": int(time.time()),
-        "auto_scheduled": True, "slot": slot_label,
-    }
-    
-    posts = _load_wall_posts()
-    posts.insert(0, post)
-    _save_wall_posts(posts)
-    
-    # Trigger short generation async
-    threading.Thread(target=lambda: asyncio.run(_auto_fetch_short(post_id)), daemon=True).start()
-    return True
-
-async def _do_scheduled_run(slot_label):
-    """Main scheduled run: 1-3 posts from 3 different HOT topics (3-9 total), no duplicates."""
-    print(f"[auto] Starting scheduled rewrite for {slot_label}")
-    
-    # Get top hot topics, skip duplicates
-    all_topics = _get_hot_topics()
-    seen_topics = set()
-    unique_topics = []
-    for t in all_topics:
-        kw = t.get('topic', '').lower().strip()
-        if kw and len(kw) > 5 and kw not in seen_topics:
-            is_dup = False
-            for s in seen_topics:
-                # Check if one topic is substring of another
-                if kw in s or s in kw:
-                    is_dup = True
-                    break
-            if not is_dup:
-                seen_topics.add(kw)
-                unique_topics.append(t)
-        if len(unique_topics) >= 3:
-            break
-    
-    job_topics = [t['topic'] for t in unique_topics[:3] if t.get('topic')]
-    if not job_topics:
-        print(f"[auto] No hot topics found, skipping")
-        return
-    
-    print(f"[auto] Running 3 topics: {job_topics}")
-    
-    # Track used URLs to avoid cross-topic duplicates
-    _used_urls = set()
-    results = []
-    
-    # Process each topic, create 1-3 posts per topic
-    for jt in job_topics:
-        for post_idx in range(3):  # Try up to 3 posts per topic
-            try:
-                ok = await asyncio.wait_for(_auto_rewrite_one(jt, slot_label, _used_urls, post_idx), timeout=120)
-                if ok:
-                    results.append((jt, post_idx, True))
-                    print(f"[auto] Created post {post_idx+1} for '{jt}'")
-                else:
-                    # No more articles for this topic
-                    break
-            except Exception as e:
-                print(f"[auto] Error on '{jt}' post {post_idx}: {e}")
-                results.append((jt, post_idx, False))
-            await asyncio.sleep(1)  # Small delay between posts
-    
-    # Ensure at least 3 posts total (fallback if needed)
-    successful_posts = sum(1 for _, _, ok in results if ok)
-    print(f"[auto] Done {slot_label}: {successful_posts} posts created")
-    
-    # Log
-    from datetime import datetime, timezone, timedelta
-    VN_TZ_SCHED = timezone(timedelta(hours=7))
-    today_str = datetime.now(VN_TZ_SCHED).strftime('%Y-%m-%d')
-    log = _load_auto_log()
-    if today_str not in log: log[today_str] = {}
-    log[today_str][slot_label] = {
-        'time': datetime.now(VN_TZ_SCHED).strftime('%H:%M:%S'),
-        'count': successful_posts,
-        'total': len(job_topics),
-    }
-    _save_auto_log(log)
-
-def _scheduler_loop():
-    """Check every 60s; trigger at 7:00, 13:00, 19:00 VN time.
-    On startup, check for any missed slots today and run them immediately."""
-    time.sleep(35)
-    from datetime import datetime, timezone, timedelta
-    VN_TZ_SCHED = timezone(timedelta(hours=7))
-    
-    _last_run_date = ""
-    _last_run_slots = set()
-    
-    # On startup: check log for missed slots today
-    try:
-        start_now = datetime.now(VN_TZ_SCHED)
-        today_str = start_now.strftime('%Y-%m-%d')
-        current_hour = start_now.hour
-        current_minute = start_now.minute
-        log = _load_auto_log()
-        today_log = log.get(today_str, {})
-        for h, label in _AUTO_SCHEDULE_TIMES:
-            # Run if slot is past (either strictly earlier hour, or same hour but window has passed)
-            should_run = False
-            if h < current_hour:
-                should_run = True
-            elif h == current_hour and current_minute > 10:
-                should_run = True
-            if should_run and label not in today_log:
-                print(f"[auto] Detected missed slot {label} (h={h} < now={current_hour}:{current_minute}), running catch-up now")
-                _run_scheduled_sync(label)
-                _last_run_slots.add(label)
-    except Exception as e:
-        print(f"[auto] Catch-up check error: {e}")
-    
-    while True:
-        try:
-            now = datetime.now(VN_TZ_SCHED)
-            today = now.strftime('%Y-%m-%d')
-            hour = now.hour
-            minute = now.minute
-            
-            if today != _last_run_date:
-                _last_run_date = today
-                _last_run_slots = set()
-            
-            slot = None
-            for h, label in _AUTO_SCHEDULE_TIMES:
-                if hour == h and 0 <= minute < 5:
-                    slot = label
-                    break
-            
-            if slot and slot not in _last_run_slots:
-                _last_run_slots.add(slot)
-                _run_scheduled_sync(slot)
-        except Exception as e:
-            print(f"[auto] Loop error: {e}")
-        
-        time.sleep(60)
-
-threading.Thread(target=_scheduler_loop, daemon=True, name='auto-rewrite-scheduler').start()
-
-@app.get('/api/debug/auto_schedule')
-async def debug_auto_schedule(slot: str = '07:00'):
-    """Manually trigger auto scheduler for debugging."""
-    try:
-        # Check if we can access the data directory
-        log = _load_auto_log()
-        topics = _get_hot_topics()[:3]
-        job_topics = [t['topic'] for t in topics if t.get('topic')]
-        return JSONResponse({
-            "slot": slot,
-            "log": log,
-            "hot_topics": job_topics,
-            "wall_posts_count": len(_load_wall_posts()),
-            "data_dir_writable": os.access(DATA_DIR, os.W_OK) if os.path.isdir(DATA_DIR) else False,
-            "data_dir_exists": os.path.isdir(DATA_DIR),
-        })
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
-
-def _run_scheduled_sync(slot):
-    """Run _do_scheduled_run in a separate event loop (for background thread)."""
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    try:
-        loop.run_until_complete(_do_scheduled_run(slot))
-    except Exception as e:
-        print(f"[auto] Background run error: {e}")
-    finally:
-        loop.close()
-
-@app.get('/api/debug/trigger_auto')
-async def debug_trigger_auto(slot: str = '19:00'):
-    """Trigger _do_scheduled_run in background thread (non-blocking)."""
-    threading.Thread(target=_run_scheduled_sync, args=(slot,), daemon=True).start()
-    return JSONResponse({"status": "started", "slot": slot})
-
-# ===== SHORTS RSS PROXY ENDPOINT =====
-@app.get("/api/shorts/rss")
-def shorts_rss():
-    """Get shorts from YouTube RSS feeds server-side"""
-    import xml.etree.ElementTree as ET
-    import html as html_lib2
-    import re as re2
-    
-    YOUTUBE_CHANNELS = {
-        "baodantri7941": "UC_x5TKhOgd6GhYvv5z4I3jg",
-        "baosuckhoedoisongboyte": "UCBsY5fXTQLkF_JnH9kLkL4g",
-    }
-    
-    shorts = []
-    seen = set()
-    
-    for handle, channel_id in YOUTUBE_CHANNELS.items():
-        try:
-            rss_url = f"https://www.youtube.com/feeds/videos.xml?channel_id={channel_id}"
-            r = req.get(rss_url, headers=HEADERS, timeout=15)
-            if r.status_code != 200:
-                continue
-            
-            root = ET.fromstring(r.text)
-            ns = {
-                'atom': 'http://www.w3.org/2005/Atom',
-                'yt': 'http://www.youtube.com/xml/schemas/2015',
-                'media': 'http://search.yahoo.com/mrss/'
-            }
-            
-            for entry in root.findall('atom:entry', ns)[:30]:
-                title_el = entry.find('atom:title', ns)
-                title = html_lib2.unescape(title_el.text) if title_el is not None and title_el.text else ''
-                
-                link_el = entry.find('atom:link', ns)
-                link = link_el.get('href', '') if link_el is not None else ''
-                
-                vid_el = entry.find('yt:videoId', ns)
-                vid = vid_el.text if vid_el is not None else ''
-                
-                if not vid or vid in seen:
-                    continue
-                
-                # Check if it's a short
-                is_short = '#shorts' in title.lower() or '#short' in title.lower() or '/shorts/' in link
-                
-                if not is_short:
-                    desc_el = entry.find('media:description', ns)
-                    if desc_el is not None and desc_el.text:
-                        if '#shorts' in desc_el.text.lower():
-                            is_short = True
-                
-                if not is_short:
-                    continue
-                
-                seen.add(vid)
-                
-                # Get thumbnail
-                thumb = f"https://i.ytimg.com/vi/{vid}/hqdefault.jpg"
-                media_group = entry.find('media:group', ns)
-                if media_group is not None:
-                    thumb_el = media_group.find('media:thumbnail', ns)
-                    if thumb_el is not None:
-                        thumb = thumb_el.get('url', thumb)
-                
-                shorts.append({
-                    'id': vid,
-                    'title': title.replace('#shorts', '').replace('#short', '').strip()[:120],
-                    'img': thumb,
-                    'link': f'https://www.youtube.com/shorts/{vid}',
-                    'channel': handle,
-                    'source': 'yt'
-                })
-                
-                if len(shorts) >= 40:
-                    break
-                    
-        except Exception as e:
-            print(f"RSS error for {handle}: {e}")
-            continue
-    
-    return {"shorts": shorts, "count": len(shorts)}
-
-app.mount('/static',StaticFiles(directory=STATIC_DIR),name='vnews_static')

main.py

@@ -1,556 +0,0 @@
-"""VNEWS - FastAPI backend with livescore + xemlaibongda highlights + VTV channels"""
-import re, time, subprocess, json, os, threading
-import html as html_lib
-from datetime import datetime, timezone, timedelta, date
-from collections import defaultdict
-
-VN_TZ = timezone(timedelta(hours=7))
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from fastapi import FastAPI, Query, Request
-from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse, Response
-from urllib.parse import quote
-import requests
-from bs4 import BeautifulSoup
-
-app = FastAPI()
-
-# ===== WORLD CUP 2026 SCRAPER =====
-from wc2026_scraper import get_wc2026_all, scrape_fixtures, scrape_standings, scrape_stats, scrape_wc_news
-
-# ===== RATE LIMITING =====
-_rate_limit_data = defaultdict(list)
-_rate_limit_lock = threading.Lock()
-RATE_LIMIT_MAX = 60
-RATE_LIMIT_WINDOW = 60
-
-def _check_rate_limit(ip: str) -> bool:
-    with _rate_limit_lock:
-        now = time.time()
-        _rate_limit_data[ip] = [t for t in _rate_limit_data[ip] if now - t < RATE_LIMIT_WINDOW]
-        if len(_rate_limit_data[ip]) >= RATE_LIMIT_MAX: return False
-        _rate_limit_data[ip].append(now)
-        return True
-
-@app.middleware("http")
-async def rate_limit_middleware(request: Request, call_next):
-    if request.url.path.startswith("/api/"):
-        ip = request.client.host
-        if not _check_rate_limit(ip): return JSONResponse({"error": "rate limit exceeded"}, status_code=429)
-    return await call_next(request)
-
-# ===== VTV CHANNELS API =====
-from vtv_api import router as vtv_router
-app.include_router(vtv_router)
-
-HEADERS = {"User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36","Accept-Language":"vi-VN,vi;q=0.9,en;q=0.8"}
-BONGDA_HEADERS = {"User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36","Accept-Language":"vi-VN,vi;q=0.9","Referer":"https://bongda.com.vn/lich-thi-dau","X-Requested-With":"XMLHttpRequest"}
-BASE_BDP = "https://bongdaplus.vn"
-_cache = {}
-_cache_ttl = 300
-_cache_ttl_live = 60
-_cache_ttl_yt = 1800
-
-PRIORITY_LEAGUES = ["Ngoại Hạng Anh","FA Cup","Champions League","LaLiga","Copa del Rey","Serie A","Bundesliga","Ligue 1","V-League"]
-LEAGUE_IDS = {"nha":27110,"laliga":27233,"seriea":27044,"bundesliga":26891,"ligue1":27212}
-HL_LEAGUES = {
-    "premier-league":{"path":"anh/premier-league","name":"Premier League","emoji":"🏴󠁧󠁢󠁥󠁮󠁧󠁿"},
-    "fa-cup":{"path":"anh/fa-cup","name":"FA Cup","emoji":"🏆"},
-    "bundesliga":{"path":"duc/bundesliga","name":"Bundesliga","emoji":"🇩🇪"},
-    "serie-a":{"path":"italy/serie-a","name":"Serie A","emoji":"🇮🇹"},
-    "la-liga":{"path":"tay-ban-nha/la-liga","name":"La Liga","emoji":"🇪🇸"},
-    "champions-league":{"path":"cup-chau-au/uefa-champions-league","name":"Champions League","emoji":"⭐"},
-    "europa-league":{"path":"cup-chau-au/uefa-europa-league","name":"Europa League","emoji":"🟠"},
-    "world-cup":{"path":"the-gioi/world-cup","name":"World Cup 2026","emoji":"🌍"},
-}
-def _cached(key, fn, ttl=None):
-    now=time.time(); t=ttl or _cache_ttl
-    if key in _cache and now-_cache[key]["t"]<t: return _cache[key]["d"]
-    try: data=fn()
-    except: data=_cache.get(key,{}).get("d",[])
-    _cache[key]={"d":data,"t":now}; return data
-def _get(url, headers=None):
-    h=headers or HEADERS; r=requests.get(url, headers=h, timeout=15); r.encoding="utf-8"
-    return BeautifulSoup(r.text,"lxml")
-def fetch_bongda_api(endpoint):
-    try:
-        r=requests.get(f"https://bongda.com.vn{endpoint}", headers=BONGDA_HEADERS, timeout=10)
-        if r.status_code==200:
-            data=r.json()
-            if data.get("status")=="success": return data.get("html","")
-        return ""
-    except: return ""
-
-def _parse_match_from_li(li, status_type="live"):
-    match_div=li.select_one("div.match")
-    if not match_div: return None
-    home_el=match_div.select_one(".home-team .name"); away_el=match_div.select_one(".away-team .name")
-    if not home_el or not away_el: return None
-    status_el=match_div.select_one(".status a"); league_el=li.find_previous("strong"); time_el=match_div.select_one(".match-time")
-    home_logo=match_div.select_one(".home-team .logo img"); away_logo=match_div.select_one(".away-team .logo img")
-    event_id=""
-    if status_el:
-        href=status_el.get("href",""); m=re.search(r'/tran-dau/(\d+)/',href)
-        if m: event_id=m.group(1)
-    spans=status_el.find_all("span") if status_el else []; score=""; minute=""
-    if len(spans)>=3: score=f"{spans[0].get_text(strip=True)} - {spans[2].get_text(strip=True)}"
-    if len(spans)>=4: minute=spans[3].get_text(strip=True)
-    if not score and status_el and status_el.select_one(".vs"): score="VS"
-    league=league_el.get_text(strip=True) if league_el else ""
-    return {"home":home_el.get_text(strip=True),"away":away_el.get_text(strip=True),"score":score or"VS","minute":minute,"league":league,"time":time_el.get_text(strip=True) if time_el else "","event_id":event_id,"home_logo":home_logo.get("src","") if home_logo else "","away_logo":away_logo.get("src","") if away_logo else "","status":status_type}
-
-# ===== VIDEO PROXY =====
-@app.get("/api/proxy/m3u8")
-def proxy_m3u8(url: str = Query(...)):
-    try:
-        r = requests.get(url, headers=HEADERS, timeout=15)
-        if r.status_code != 200: return Response(status_code=502, content="upstream error")
-        lines = r.text.strip().split('\n'); rewritten = []
-        for line in lines:
-            if line.startswith('#') or not line.strip(): rewritten.append(line)
-            else: rewritten.append("/api/proxy/seg?url=" + quote(line.strip(), safe=""))
-        return Response(content='\n'.join(rewritten).encode('utf-8'), media_type="application/vnd.apple.mpegurl", headers={"Access-Control-Allow-Origin":"*","Cache-Control":"public, max-age=300"})
-    except: return Response(status_code=502, content="proxy error")
-
-@app.get("/api/proxy/seg")
-def proxy_segment(url: str = Query(...)):
-    try:
-        r = requests.get(url, headers=HEADERS, timeout=30)
-        if r.status_code != 200: return Response(status_code=502, content="upstream error")
-        data = r.content
-        if len(data) > 188 and data[0:4] == b'\x89PNG' and data[188] == 0x47: data = data[188:]
-        return Response(content=data, media_type="video/mp2t", headers={"Access-Control-Allow-Origin":"*","Cache-Control":"public, max-age=3600"})
-    except: return Response(status_code=502, content="proxy error")
-
-@app.get("/api/proxy/video")
-def proxy_video(url: str = Query(...), request: Request = None):
-    try:
-        req_headers = dict(HEADERS)
-        if request and request.headers.get("range"): req_headers["Range"] = request.headers["range"]
-        r = requests.get(url, headers=req_headers, timeout=30, stream=True)
-        resp_headers = {"Access-Control-Allow-Origin":"*","Accept-Ranges":"bytes","Content-Type":r.headers.get("Content-Type","video/mp4")}
-        if "Content-Range" in r.headers: resp_headers["Content-Range"] = r.headers["Content-Range"]
-        if "Content-Length" in r.headers: resp_headers["Content-Length"] = r.headers["Content-Length"]
-        return StreamingResponse(r.iter_content(chunk_size=256*1024), status_code=r.status_code, headers=resp_headers)
-    except: return Response(status_code=502, content="proxy error")
-
-@app.get("/api/proxy/img")
-def proxy_img(url: str = Query(...)):
-    try:
-        from urllib.parse import urlparse
-        _u = urlparse(url); _host = _u.netloc.lower()
-        _referer = "https://dantri.com.vn/"
-        if "refooty" in _host or "xemlaibongda" in _host: _referer = "https://xemlaibongda.top/"
-        elif "ytimg" in _host or "youtube" in _host: _referer = "https://www.youtube.com/"
-        elif "vncecdn" in _host or "vnexpress" in _host: _referer = "https://vnexpress.net/"
-        r = requests.get(url, headers={**HEADERS, "Referer": _referer}, timeout=10)
-        if r.status_code != 200: return Response(status_code=502)
-        return Response(content=r.content, media_type=r.headers.get("Content-Type", "image/jpeg"), headers={"Cache-Control": "public, max-age=86400", "Access-Control-Allow-Origin": "*"})
-    except: return Response(status_code=502)
-
-# ===== XEMLAIBONGDA HIGHLIGHTS =====
-def _scrape_xemlaibongda_page(page_path, limit=20):
-    try:
-        url = f"https://xemlaibongda.top/{page_path}" if page_path else "https://xemlaibongda.top/"
-        r = requests.get(url, headers=HEADERS, timeout=15)
-        if r.status_code != 200: return []
-        r.encoding = "utf-8"
-        soup = BeautifulSoup(r.text, "lxml")
-        videos = []; seen = set()
-        for a in soup.find_all("a", href=True):
-            href = a.get("href", "")
-            if "/video/" not in href and "/xem-lai/" not in href: continue
-            if not href.startswith("http"): href = "https://xemlaibongda.top" + href
-            clean_href = href.split("?")[0].split("#")[0]
-            if clean_href in seen: continue
-            seen.add(clean_href)
-            img_src = ""
-            img = a.find("img")
-            if not img and a.parent: img = a.parent.find("img")
-            if not img:
-                p = a.parent
-                for _ in range(4):
-                    if p and p.find("img"): img = p.find("img"); break
-                    p = p.parent if p else None
-            if img:
-                img_src = (img.get("data-src", "") or img.get("src", "") or img.get("data-lazy", "") or img.get("data-original", "") or img.get("data-thumb", "") or img.get("data-image", ""))
-                if img_src.startswith("//"): img_src = "https:" + img_src
-                elif img_src.startswith("/"): img_src = "https://xemlaibongda.top" + img_src
-            if not img_src:
-                p = a.parent
-                for _ in range(5):
-                    if p is None: break
-                    style = p.get("style", "")
-                    bg_match = re.search(r'url\(["\']?(.*?)["\']?\)', style)
-                    if bg_match:
-                        img_src = bg_match.group(1)
-                        if img_src.startswith("//"): img_src = "https:" + img_src
-                        elif img_src.startswith("/"): img_src = "https://xemlaibongda.top" + img_src
-                        break
-                    p = p.parent if p else None
-            title = ""
-            for attr in ["title", "aria-label"]:
-                val = a.get(attr, "")
-                if val and len(val) >= 5: title = val; break
-            if not title:
-                for selector in ["h3", "h2", "h4", ".title", ".video-title", "strong"]:
-                    try:
-                        el = a.select_one(selector)
-                        if el: t = el.get_text(strip=True)
-                        if t and len(t) >= 5: title = t; break
-                    except: pass
-            if not title:
-                text = a.get_text(strip=True)
-                if text and len(text) >= 5: title = text[:100]
-            if not title or len(title) < 3:
-                slug = clean_href.split("/video/")[-1].rstrip("/").split("/xem-lai/")[-1].rstrip("/")
-                title = slug.replace("-", " ").replace("_", " ").title()
-                title = re.sub(r'\d{4}-\d{2}-\d{2}', '', title).strip()
-            if not title or len(title) < 3: continue
-            if not img_src:
-                slug = clean_href.split("/video/")[-1].rstrip("/").split("/xem-lai/")[-1].rstrip("/")
-                img_src = f"https://xemlaibongda.top/uploads/thumb/{slug}.jpg"
-            videos.append({"title": title[:100], "link": clean_href, "img": img_src, "source": "xemlaibongda"})
-            if len(videos) >= limit: break
-        return videos
-    except Exception as e:
-        print(f"[xemlaibongda] Error: {e}"); return []
-
-def scrape_xemlaibongda(): return _scrape_xemlaibongda_page("", 20)
-def scrape_highlights_by_league(league_key):
-    if league_key not in HL_LEAGUES: return []
-    return _scrape_xemlaibongda_page(HL_LEAGUES[league_key]["path"], 20)
-def scrape_all_league_highlights():
-    results = {}
-    def _fetch(key): return key, scrape_highlights_by_league(key)
-    with ThreadPoolExecutor(8) as ex:
-        futs = [ex.submit(_fetch, k) for k in HL_LEAGUES]
-        for f in as_completed(futs, timeout=25):
-            try: key, vids = f.result()
-            except: continue
-            if vids: results[key] = vids
-    return results
-
-def extract_xemlaibongda_video(url):
-    try:
-        r=requests.get(url, headers=HEADERS, timeout=15)
-        if r.status_code!=200: return None
-        r.encoding="utf-8"; soup=BeautifulSoup(r.text,"lxml")
-        og=soup.find("meta",property="og:image")
-        og_poster=og.get("content","") if og else ""
-        if og_poster.startswith("//"): og_poster="https:"+og_poster
-        video=soup.find("video")
-        if video:
-            src=video.get("src",""); poster=video.get("poster","")
-            if not src:
-                source=video.find("source")
-                if source: src=source.get("src","")
-            if not poster: poster=og_poster
-            if src: return{"src":src,"poster":poster,"type":"hls" if".m3u8" in src else"video"}
-        m3u8s=re.findall(r'(https?://[^\s"\'<>]+\.m3u8)',r.text)
-        if m3u8s: return{"src":m3u8s[0],"poster":og_poster,"type":"hls"}
-        yt_iframe = soup.find("iframe", src=re.compile(r"youtube\.com/embed|youtube-nocookie\.com/embed"))
-        if yt_iframe: return{"src":yt_iframe.get("src",""),"poster":og_poster,"type":"youtube"}
-        return None
-    except: return None
-
-# ===== LIVESCORE =====
-@app.get("/api/livescore/live")
-def api_livescore_live(): return JSONResponse({"html":_cached("ls_live",lambda:fetch_bongda_api("/api/fixtures/live"),ttl=_cache_ttl_live)})
-@app.get("/api/livescore/incoming")
-def api_livescore_incoming(): return JSONResponse({"html":_cached("ls_incoming",lambda:fetch_bongda_api("/api/fixtures/incoming"),ttl=_cache_ttl_live)})
-@app.get("/api/livescore/today")
-def api_livescore_today():
-    today=datetime.now(VN_TZ).strftime("%Y-%m-%d");return JSONResponse({"html":_cached("ls_today",lambda:fetch_bongda_api(f"/api/fixtures/get-by-date?date={today}"),ttl=_cache_ttl)})
-@app.get("/api/livescore/results")
-def api_livescore_results():
-    today=datetime.now(VN_TZ).strftime("%Y-%m-%d");return JSONResponse({"html":_cached("ls_results",lambda:fetch_bongda_api(f"/api/fixtures/get-by-date?date={today}&status=finished"),ttl=_cache_ttl)})
-@app.get("/api/livescore/standings/{league}")
-def api_livescore_standings(league:str):
-    tid=LEAGUE_IDS.get(league,27110);return JSONResponse({"html":_cached(f"ls_bxh_{league}",lambda:fetch_bongda_api(f"/api/league-table/home?tournament_id={tid}&is_detail=True"),ttl=_cache_ttl)})
-@app.get("/api/livescore/date/{date}")
-def api_livescore_date(date:str):return JSONResponse({"html":fetch_bongda_api(f"/api/fixtures/get-by-date?date={date}")})
-
-@app.get("/api/livescore/updates7d")
-def api_livescore_updates7d():
-    """Aggregate results + incoming matches from past 7 days and next 7 days."""
-    def _f():
-        from datetime import date as _date
-        today = _date.today()
-        all_html = []
-        # Past 7 days (results)
-        for i in range(7, 0, -1):
-            d = (today - timedelta(days=i)).strftime("%Y-%m-%d")
-            html = fetch_bongda_api(f"/api/fixtures/get-by-date?date={d}&status=finished")
-            if html and len(html) > 50:
-                soup = BeautifulSoup(html, "lxml")
-                day_label = (today - timedelta(days=i)).strftime("%d/%m")
-                for match in soup.select(".match-detail"):
-                    dt = soup.new_tag("div", **{"class": "datetime"})
-                    dt.string = f"📅 {day_label}"
-                    match.insert(0, dt)
-                all_html.append(str(soup))
-        # Next 7 days (upcoming)
-        for i in range(7):
-            d = (today + timedelta(days=i)).strftime("%Y-%m-%d")
-            html = fetch_bongda_api(f"/api/fixtures/get-by-date?date={d}")
-            if html and len(html) > 50:
-                soup = BeautifulSoup(html, "lxml")
-                day_label = (today + timedelta(days=i)).strftime("%d/%m")
-                for match in soup.select(".match-detail"):
-                    dt = soup.new_tag("div", **{"class": "datetime"})
-                    dt.string = f"📅 {day_label}"
-                    match.insert(0, dt)
-                all_html.append(str(soup))
-        combined = "<div class='updates7d'>" + "".join(all_html) + "</div>"
-        return combined if all_html else ""
-    return JSONResponse({"html": _cached("ls_updates7d", _f, ttl=_cache_ttl)})
-
-@app.get("/api/match/{event_id}/commentaries")
-def api_match_commentaries(event_id:int):return JSONResponse({"html":fetch_bongda_api(f"/api/fixtures/commentaries?event_id={event_id}")})
-@app.get("/api/match/{event_id}/stats")
-def api_match_stats(event_id:int):return JSONResponse({"html":fetch_bongda_api(f"/api/event-standing/player-performance?event_id={event_id}")})
-
-from match_detail_v2 import fetch_match_detail, fetch_match_detail_by_url
-
-@app.get("/api/match/{event_id}/detail")
-def api_match_detail(event_id: int, url: str = Query(default="")):
-    try:
-        if url: data = fetch_match_detail_by_url(url)
-        else: data = fetch_match_detail(event_id)
-        return JSONResponse(data)
-    except Exception as e: return JSONResponse({"event_id": event_id, "found": False, "error": str(e)})
-
-@app.get("/api/livescore/featured")
-def api_livescore_featured():
-    def _f():
-        sources=[("/api/fixtures/live","live"),("/api/fixtures/get-by-date?date="+datetime.now(VN_TZ).strftime("%Y-%m-%d"),"today"),("/api/fixtures/incoming","upcoming")]
-        for endpoint, stype in sources:
-            html=fetch_bongda_api(endpoint)
-            if not html or len(html)<100:continue
-            soup=BeautifulSoup(html,"lxml");all_matches=[]
-            for li in soup.select("li.match-detail"):
-                match=_parse_match_from_li(li, stype)
-                if not match or not match["event_id"]:continue
-                if stype=="today" and "KT" in match.get("minute",""):continue
-                all_matches.append(match)
-            if not all_matches:continue
-            for pl in PRIORITY_LEAGUES:
-                for match in all_matches:
-                    if pl in match["league"]:return match
-            return all_matches[0]
-        return None
-    return JSONResponse(_cached("ls_featured",_f,ttl=30))
-
-@app.get("/api/highlights")
-def api_highlights(): return JSONResponse(_cached("xemlaibongda_hl",scrape_xemlaibongda,ttl=_cache_ttl))
-@app.get("/api/highlights/leagues")
-def api_highlights_leagues(): return JSONResponse(_cached("hl_leagues",scrape_all_league_highlights,ttl=_cache_ttl))
-@app.get("/api/highlights/{league}")
-def api_highlights_league(league:str):
-    if league not in HL_LEAGUES: return JSONResponse({"error":"league not found"})
-    return JSONResponse(_cached(f"hl_{league}",lambda:scrape_highlights_by_league(league),ttl=_cache_ttl))
-
-@app.get("/api/video_url")
-def api_video_url(url:str=Query(...), img:str=Query(default="")):
-    if "youtube.com" in url or "youtu.be" in url:
-        m=re.search(r'(?:v=|shorts/|youtu\.be/)([a-zA-Z0-9_-]{11})',url)
-        if m: vid=m.group(1); return JSONResponse({"src":f"https://www.youtube.com/embed/{vid}?autoplay=1&rel=0&enablejsapi=1","poster":f"https://i.ytimg.com/vi/{vid}/hqdefault.jpg","type":"youtube"})
-    if "xemlaibongda.top" in url:
-        v=extract_xemlaibongda_video(url)
-        if v:
-            if v["type"]=="hls": v["src"]="/api/proxy/m3u8?url="+quote(v["src"],safe="")
-            if not v.get("poster") and img: v["poster"] = img
-            return JSONResponse(v)
-    return JSONResponse({"error":"not found"})
-
-# ===== WORLD CUP 2026 API =====
-_wc_request_times = []; _wc_rate_limit_lock = threading.Lock()
-_WC_RATE_LIMIT = 10
-def _wc_rate_limit():
-    global _wc_request_times
-    with _wc_rate_limit_lock:
-        now = time.time()
-        _wc_request_times = [t for t in _wc_request_times if now - t < 60]
-        if len(_wc_request_times) >= _WC_RATE_LIMIT: return False
-        _wc_request_times.append(now)
-        return True
-
-@app.get("/api/wc2026")
-def api_wc2026():
-    return JSONResponse(_cached("wc2026", get_wc2026_all, ttl=_cache_ttl))
-
-@app.get("/api/wc2026/{tab}")
-def api_wc2026_tab(tab: str):
-    valid_tabs = ["news", "fixtures", "standings", "stats", "highlights"]
-    if tab not in valid_tabs: return JSONResponse({"error": "invalid tab"}, status_code=400)
-    def _fetch_tab():
-        if tab == "highlights": return scrape_highlights_by_league("world-cup")
-        elif tab == "news": return scrape_wc_news()
-        elif tab == "fixtures": return scrape_fixtures()
-        elif tab == "standings": return scrape_standings()
-        elif tab == "stats": return scrape_stats()
-        return []
-    return JSONResponse(_cached(f"wc2026_{tab}", _fetch_tab, ttl=_cache_ttl))
-
-@app.get("/api/bdp_videos")
-def api_bdp_videos():
-    def _f():
-        try:
-            soup=_get(f"{BASE_BDP}/video"); arts=[]; seen=set()
-            for a in soup.find_all("a",href=True):
-                href=a.get("href","")
-                if"/video/" not in href or href in("/video/","/video/ban-thang-dep","/video/highlight"):continue
-                if not href.startswith("http"): href=BASE_BDP+href
-                if href in seen: continue
-                title=re.sub(r'^\d{2}:\d{2}','',a.get_text(strip=True)).strip()
-                if not title or len(title)<5: continue
-                img_tag=a.find("img") or(a.parent.find("img") if a.parent else None)
-                img=(img_tag.get("data-src") or img_tag.get("src","")) if img_tag else ""
-                seen.add(href); arts.append({"title":title,"link":href,"img":img,"source":"bdp"})
-            return arts[:20]
-        except: return []
-    return JSONResponse(_cached("bdp_videos",_f))
-
-# ===== NEWS =====
-VNE_CATS={"thoi-su":("https://vnexpress.net/thoi-su","Thời Sự"),"the-gioi":("https://vnexpress.net/the-gioi","Thế Giới"),"kinh-doanh":("https://vnexpress.net/kinh-doanh","Kinh Doanh"),"the-thao":("https://vnexpress.net/the-thao","Thể Thao"),"giai-tri":("https://vnexpress.net/giai-tri","Giải Trí"),"suc-khoe":("https://vnexpress.net/suc-khoe","Sức Khỏe"),"phap-luat":("https://vnexpress.net/phap-luat","Pháp Luật"),"giao-duc":("https://vnexpress.net/giao-duc","Giáo Dục"),"du-lich":("https://vnexpress.net/du-lich","Du Lịch"),"doi-song":("https://vnexpress.net/doi-song","Đời Sống")}
-
-def scrape_vne(cat_url):
-    try:
-        soup=_get(cat_url); arts=[]
-        for it in soup.select("article.item-news")[:15]:
-            a=it.select_one("h2.title-news a") or it.select_one("h3.title-news a")
-            if not a: continue
-            t=a.get("title","") or a.get_text(strip=True); lk=a.get("href","")
-            if not t or not lk: continue
-            im=it.find("img"); img=(im.get("data-src") or im.get("src","")) if im else ""
-            if img and 'blank' in img:
-                src=it.find("source")
-                if src: img=src.get("srcset","").split(",")[0].strip().split(" ")[0]
-            arts.append({"title":t,"link":lk,"img":img,"source":"vne"})
-        return arts
-    except: return []
-
-def scrape_genk_ai():
-    try:
-        r=requests.get("https://genk.vn/ai.chn",headers=HEADERS,timeout=15)
-        if r.status_code!=200: return []
-        r.encoding="utf-8"; soup=BeautifulSoup(r.text,"lxml"); articles=[]; seen=set()
-        for a in soup.find_all("a",href=True):
-            href=a.get("href","")
-            if not href.endswith(".chn") or href=="/ai.chn": continue
-            if href.startswith("/"): href="https://genk.vn"+href
-            if href in seen or "genk.vn" not in href: continue
-            title=a.get("title","") or a.get_text(strip=True)
-            if not title or len(title)<20: continue
-            container=a.parent; img_src=""
-            for _ in range(6):
-                if container is None: break
-                for img in container.find_all("img"):
-                    s=img.get("data-src","") or img.get("src","")
-                    if s and "mediacdn" in s and "avatar" not in s and "logo" not in s: img_src=s; break
-                if img_src: break; container=container.parent
-            seen.add(href)
-            if not img_src:
-                try:
-                    og_r=requests.get(href,headers=HEADERS,timeout=8); og_r.encoding="utf-8"
-                    og_soup=BeautifulSoup(og_r.text,"lxml"); og_tag=og_soup.find("meta",property="og:image")
-                    if og_tag: img_src=og_tag.get("content","")
-                except: pass
-            articles.append({"title":title,"link":href,"img":img_src,"source":"genk"})
-            if len(articles)>=30: break
-        return articles
-    except: return []
-
-@app.get("/api/homepage")
-def api_homepage():
-    def _f():
-        articles=[]
-        with ThreadPoolExecutor(12) as ex:
-            futs={ex.submit(scrape_vne,VNE_CATS[k][0]):VNE_CATS[k][1] for k in["thoi-su","the-gioi","kinh-doanh","the-thao","giai-tri","phap-luat","giao-duc","du-lich","doi-song"]}
-            for f in as_completed(futs):
-                try:
-                    for a in f.result(): a["group"]=futs[f]; articles.append(a)
-                except: pass
-        return articles
-    return JSONResponse(_cached("homepage",_f))
-
-@app.get("/api/category/{cat_id}")
-def api_category(cat_id:str):
-    def _f():
-        if cat_id=="cong-nghe": return scrape_genk_ai()
-        if cat_id in VNE_CATS:
-            arts=scrape_vne(VNE_CATS[cat_id][0])
-            [a.update({"group":VNE_CATS[cat_id][1]}) for a in arts]
-            return arts
-        return []
-    return JSONResponse(_cached(f"cat_{cat_id}",_f))
-
-@app.get("/api/categories")
-def api_categories():
-    cats=[{"id":"cong-nghe","name":"Công Nghệ","source":"genk"}]
-    for k,(u,n) in VNE_CATS.items(): cats.append({"id":k,"name":n,"source":"vne"})
-    return JSONResponse(cats)
-
-@app.get("/api/proxy/xlb")
-def api_xlb(path: str = Query(default=""), limit: int = Query(default=20)):
-    try:
-        url = f"https://xemlaibongda.top/{path}" if path else "https://xemlaibongda.top/"
-        r = requests.get(url, headers=HEADERS, timeout=15)
-        if r.status_code != 200: return JSONResponse({"videos": []})
-        r.encoding = "utf-8"
-        soup = BeautifulSoup(r.text, "lxml")
-        videos, seen = [], set()
-        for a in soup.find_all("a", href=True):
-            href = a.get("href", "")
-            if "/video/" not in href and "/xem-lai/" not in href: continue
-            if not href.startswith("http"): href = "https://xemlaibongda.top" + href
-            clean = href.split("?")[0].split("#")[0]
-            if clean in seen: continue
-            seen.add(clean)
-            img_src = ""
-            img = a.find("img") or (a.parent.find("img") if a.parent else None)
-            if not img:
-                p = a.parent
-                for _ in range(5):
-                    if p and p.find("img"): img = p.find("img"); break
-                    p = p.parent if p else None
-            if img:
-                img_src = (img.get("data-src", "") or img.get("src", "") or img.get("data-lazy", "") or img.get("data-original", ""))
-                if img_src.startswith("//"): img_src = "https:" + img_src
-                elif img_src.startswith("/"): img_src = "https://xemlaibongda.top" + img_src
-            title = a.find("h3")
-            if not title: title = a.find("h2")
-            if not title: title = a.find("strong")
-            t = title.get_text(strip=True) if title else ""
-            if not t:
-                slug = clean.split("/video/")[-1].rstrip("/")
-                t = slug.replace("-", " ").title()
-            videos.append({"title": t[:100], "link": clean, "img": img_src, "source": "xemlaibongda"})
-            if len(videos) >= limit: break
-        return JSONResponse({"videos": videos})
-    except Exception as e:
-        return JSONResponse({"videos": [], "error": str(e)})
-
-@app.get("/api/article")
-def api_article(url:str=Query(...)):
-    try:
-        r2 = requests.get(url, headers=HEADERS, timeout=10)
-        if r2.status_code == 200:
-            r2.encoding = "utf-8"
-            soup = BeautifulSoup(r2.text, "lxml")
-            og = soup.find("meta", property="og:image")
-            return JSONResponse({"og_image": og.get("content", "") if og else ""})
-    except: pass
-    return JSONResponse({"og_image": ""})
-
-@app.get("/api/storage_status")
-def api_storage_status():
-    return JSONResponse({"persistent":os.path.isdir("/data")})
-
-@app.get("/api/hot_topics")
-def api_hot_topics():
-    return JSONResponse({"topics":[]})
-
-@app.get("/", response_class=HTMLResponse)
-async def root():
-    return HTMLResponse("<h1>VNEWS v17</h1><p>VTV Digital CDN ssaimh · No shorts Dantri/SKDS · Homepage full content</p>")