Fix rewrite URL and short JSON handling

app_v2_entry.py

@@ -226,7 +226,7 @@ _STOP=set('và của các những một được trong với cho tại sau trư
 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]
+    words=[w for w in re.findall(r'[A-Za-zÀ-ỹ0-9]+',tl) if len(w)>2 and w.lower() not in _STOP]
     if not words:return True
     return any(w in tt for w in words)
 
@@ -498,9 +498,9 @@ def _get_hot_topics():
         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
+        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 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]
 
@@ -810,7 +810,7 @@ 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')
+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')
@@ -821,43 +821,54 @@ os.makedirs(WALL_VIDEO_DIR,exist_ok=True)
 _il=threading.Lock();_cl=threading.Lock();_wl_lock=threading.Lock()
 def _lj(p):
     try:
+        p=str(p)
         if os.path.exists(p):return json.load(open(p,'r',encoding='utf-8'))
     except:pass
-    return{}
+    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)
+    try:
+        p=str(p)
+        os.makedirs(os.path.dirname(p),exist_ok=True)
+        tmp=p+'.tmp'
+        with open(tmp,'w',encoding='utf-8') as f:
+            json.dump(d,f,ensure_ascii=False)
+        os.replace(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}))
+def _wall_posts_list():
+    posts = _load_wall_posts()
+    return posts if isinstance(posts, list) else []
 
-@app.get('/api/v2/comments')
-def _gc(id:str=Query(...)):
-    with _cl:return JSONResponse({'comments':_lj(CF).get(id.strip(),[])})
+def _append_wall_post(post):
+    posts = _wall_posts_list()
+    posts.insert(0, post)
+    posts = posts[:200]
+    _save_wall_posts(posts)
+    return posts
 
-@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})
+@app.get('/api/ai/wall')
+def api_ai_wall():
+    return JSONResponse({"posts": _wall_posts_list()})
 
-def _load_wall_posts():
-    with _wl_lock:
-        return _lj(WALL_FILE)
+@app.post("/api/ai/short/{post_id}")
+def api_ai_short(post_id: str, request: Request):
+    """Generate a short video for a wall post.
 
-def _save_wall_posts(posts):
-    with _wl_lock:
-        _sj(WALL_FILE, posts)
+    This endpoint intentionally returns a clear JSON error when video generation is not
+    available yet, instead of crashing FastAPI with an invalid JSON response.
+    """
+    post = None
+    post_id_s = str(post_id)
+    for p in _wall_posts_list():
+        pid = str(p.get('id', ''))
+        if pid == post_id_s or pid.startswith(post_id_s):
+            post = p
+            break
+    if not post:
+        return JSONResponse({'error': 'Không tìm thấy bài viết', 'post_id': post_id}, status_code=404)
+    if post.get('video'):
+        return JSONResponse({'video': post['video'], 'post': post})
+    return JSONResponse({'error': 'Chưa có video cho bài này. Vui lòng upload video trước.'}, status_code=409)
 
 @app.get('/api/wall')
 def api_wall():
@@ -993,7 +1004,7 @@ _UNIQUE_CHARS = {
 _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'},
+    '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', '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'},
 }
 
@@ -1045,1313 +1056,4 @@ _EMOTION_KEYWORDS = {
         '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 =====
-
-# ===== KEYWORD EXTRACTION FROM OPINION =====
-_STOP_WORDS_EX = 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 đã để về lại nên cũng rất như vì do nếu sẽ nếu thế nhưng mà vẫn 
-đang vào ra hơn đây đó nào cả cùng đã từng hãy còn chỉ cũng đều khiến 
-được đã bị bởi qua những lúc cái gì cô chú bác anh chị em bạn tôi mình 
-ông bà thầy vì vậy chính phải ấy đấy đâu đó thôi nhé đấy ạ nhỉ 
-ngày tháng năm giờ phút giây tuần tháng quý
-""".strip().split())
-
-def _extract_keywords_from_opinion(text, max_keywords=5):
-    """Extract meaningful keywords from user's opinion for news search."""
-    if not text:
-        return []
-    text = text.lower()
-    text = re.sub(r'https?://\S+', '', text)
-    text = re.sub(r'[^\w\sÀ-ỹ]', ' ', text)
-    text = re.sub(r'\s+', ' ', text).strip()
-    words = [w for w in text.split() if len(w) > 2 and w not in _STOP_WORDS_EX]
-    word_scores = {}
-    for w in words:
-        word_scores[w] = word_scores.get(w, 0) + 1
-    sorted_words = sorted(word_scores.items(), key=lambda x: -x[1])
-    top_words = [w for w, s in sorted_words[:max_keywords]]
-    phrases = []
-    for i in range(len(words) - 1):
-        phrase = words[i] + ' ' + words[i + 1]
-        if len(phrase) > 5:
-            phrases.append(phrase)
-    phrase_scores = {}
-    for p in phrases:
-        phrase_scores[p] = phrase_scores.get(p, 0) + 1
-    sorted_phrases = sorted(phrase_scores.items(), key=lambda x: -x[1])
-    top_phrases = [p for p, s in sorted_phrases[:3]]
-    result = []
-    for p in top_phrases:
-        if p not in result:
-            result.append(p)
-    for w in top_words:
-        if w not in result:
-            result.append(w)
-    return result[:max_keywords]
-
-
-@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 keywords từ QUAN ĐIỂM CÁ NHÂN để tìm nguồn tin chính xác
-    keywords = _extract_keywords_from_opinion(opinion, max_keywords=5)
-    if keywords:
-        selected_topics = keywords[:3]
-    else:
-        # Fallback: hot 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 = (
-                "QUAN ĐIỂM: " + opinion[:500] + "\nNGUỒN: " + source_context[:1000] + "\n\n"
-                "=== NGUỒN TIN THAM KHẢO ===\n" + source_context + "\n\n"
-                "=== YÊU CẦU VIẾT BÀI THEO SLIDE ===\n"
-                "Viết bài thành 5-6 ĐOẠN VĂN NGẮN, mỗi đoạn là 1 SLIDE.\n"
-                "\n"
-                "QUAN TRỌNG NHẤT: MỗI SLIDE PHẢI KẾT HỢP QUAN ĐIỂM CÁ NHÂN + NỘI DUNG NGUỒN TIN, KHÔNG PHẢI CHỈ NÓI VỀ NGUỒN TIN.\n"
-                "\n"
-                "SLIDE 1 - MỞ ĐẦU:\n"
-                "- NHIỆN HỮU QUAN ĐIỂM CÁ NHÂN LÊN ĐẦU\n"
-                "- Giới thiệu chủ đề, nêu rõ quan điểm của bạn (dựa vào QUAN ĐIỂM CÁ NHÂN ở trên)\n"
-                "- 2-4 câu hoàn chỉnh\n"
-                "\n"
-                "SLIDE 2-3-4-5 - PHÂN TÍCH:\n"
-                "- Mỗi slide: B�Commencer bằng QUAN ĐIỂM CÁ NHÂN, sau đó dẫn chứng từ 1 nguồn tin\n"
-                "- Ví dụ: \"Theo quan điểm của tôi, đây là vấn đề cần lưu ý. Theo VnExpress...\"\n"
-                "- Dẫn chứng từ nguồn (ghi rõ tên báo: Theo VnExpress, Theo Thanh Niên...)\n"
-                "- 2-4 câu hoàn chỉnh mỗi slide\n"
-                "\n"
-                "SLIDE 6 - KẾT LUẬN:\n"
-                "- Tổng kết quan điểm cá nhân, đưa ra nhận định cuối cùng\n"
-                "- 2-3 câu hoàn chỉnh\n"
-                "\n"
-                "Định dạng đầu ra:\n"
-                "---SLIDE 1---\n"
-                "[nội dung đoạn văn slide 1]\n"
-                "---SLIDE 2---\n"
-                "[nội dung đoạn văn slide 2]\n"
-                "...v.v...\n"
-                "\n"
-                "QUAN TRỌNG:\n"
-                "- Mỗi slide là 1 đoạn văn HOÀN CHỈNH, 2-4 câu\n"
-                "- PHẢI KẾT THÚC BẰNG DẤU CHẤM (.) HOẢN TOÀN\n"
-                "- Kết hợp QUAN ĐIỂM CÁ NHÂN với NỘI DUNG NGUỒN TIN\n"
-                "- Không gạch đầu dòng, không bullet points\n"
-                "- Viết liền mạch tự nhiên, giọng văn báo chí\n"
-                "- Mỗi slide phải khác nhau, không lặp ý\n"
-                "- Độ dài: 300-600 từ"
-            )
-            ai_text = None  # Không dùng AI, để code tự kết hợp opinion + source
-    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*"
-    
-    # Parse slides từ AI output (format: ---SLIDE N--- content)
-    slides = []
-    if ai_text:
-        # Try to parse the ---SLIDE--- format
-        pattern = r'---SLIDE\s*(\d+)---\s*\n(.*?)(?=---SLIDE|\Z)'
-        matches = re.findall(pattern, ai_text, re.DOTALL)
-        
-        if matches:
-            for idx, (num, content) in enumerate(matches):
-                # Normalize: ensure complete sentences
-                text = _ensure_sentence_complete(content)
-                if len(text) > 40:
-                    img = source_images[idx] if idx < len(source_images) else ""
-                    slides.append({"text": text, "image": img, "index": idx + 1})
-        
-        # If we have parsed slides, ensure minimum 3
-        if len(slides) < 3:
-            # Use parsed slides as base, fill remaining from AI text
-            used_indices = set()
-            for s in slides:
-                used_indices.add(s['index'] - 1)
-            
-            # Split remaining AI text into more slides
-            sentences = re.split(r'(?<=[.!?])\s+', ai_text)
-            current_chunk = ""
-            next_idx = len(slides)
-            
-            for sent in sentences:
-                sent = _ensure_sentence_complete(sent)
-                if len(sent) < 20:
-                    continue
-                
-                # Skip if this sentence is already in parsed slides
-                found = False
-                for slide in slides:
-                    if sent[:50] in slide['text']:
-                        found = True
-                        break
-                
-                if found:
-                    continue
-                    
-                if current_chunk and len(current_chunk + " " + sent) <= 380:
-                    current_chunk += " " + sent
-                else:
-                    if len(current_chunk) > 50:
-                        img = source_images[next_idx] if next_idx < len(source_images) else ""
-                        slides.append({"text": current_chunk, "image": img, "index": next_idx + 1})
-                    current_chunk = sent
-                    next_idx += 1
-            
-            # Add final chunk
-            if len(current_chunk) > 50 and next_idx < 6:
-                img = source_images[next_idx] if next_idx < len(source_images) else ""
-                slides.append({"text": current_chunk, "image": img, "index": next_idx + 1})
-    
-    # Ultimate fallback: create slides from opinion + source
-    if len(slides) < 2:
-        slides = []
-        # Slide 1: opinion
-        if opinion and len(opinion) > 20:
-            slides.append({"text": opinion[:450], "image": source_images[0] if source_images else "", "index": 1})
-        
-        # Slide 2-6: from AI text or sources
-        if ai_text:
-            sentences = re.split(r'(?<=[.!?])\s+', ai_text)
-            for i, sent in enumerate(sentences[:5]):
-                text = _ensure_sentence_complete(_clean(sent))
-                if len(text) > 60:
-                    if len(slides) < 6:
-                        img = source_images[len(slides)] if len(slides) < len(source_images) else ""
-                        slides.append({"text": text, "image": img, "index": len(slides) + 1})
-        
-        # Fill remaining with key points from sources - KẾT HỢP VỚI QUAN ĐIỂM CÁ NHÂN
-        src_idx = len(slides)
-        while len(slides) < 4 and src_idx < len(source_details):
-            paragraphs = source_details[src_idx].get("paragraphs", [])
-            src_title = source_details[src_idx].get("title", "")
-            src_via = source_details[src_idx].get("via", "")
-            for p in paragraphs[:2]:
-                if len(p) > 60 and len(slides) < 6:
-                    # Kết hợp opinion với nội dung source
-                    combined = f"Theo góc nhìn của tôi, {opinion[:100]}... Theo {src_via}: {p[:250]}"
-                    img = source_images[len(slides)] if len(slides) < len(source_images) else ""
-                    slides.append({"text": _ensure_sentence_complete(combined), "image": img, "index": len(slides) + 1})
-                    break  # Mỗi nguồn 1 slide
-            src_idx += 1
-        
-        # Final fallback: ensure at least 2-3 slides
-        while len(slides) < 3:
-            idx = len(slides)
-            if idx == 0 and opinion:
-                slides.append({"text": opinion[:400], "image": "", "index": 1})
-            elif ai_text:
-                slides.append({"text": ai_text[idx*300:(idx+1)*300], "image": "", "index": idx + 1})
-            else:
-                slides.append({"text": f"Nguồn tham khảo {idx + 1}", "image": "", "index": idx + 1})
-    
-    preview = {
-        "title": title,
-        "text": ai_text,
-        "opinion": opinion,
-        "images": source_images[:10],
-        "sources": source_details[:5],
-        "slides": slides[:6]  # Max 6 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:
-        # Lấy keywords từ QUAN ĐIỂM CÁ NHÂN để tìm nguồn tin chính xác
-        keywords = _extract_keywords_from_opinion(opinion, max_keywords=5)
-        if keywords:
-            selected_topics = keywords[:3]
-        else:
-            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 = (
-                "QUAN ĐIỂM: " + opinion[:500] + "\nNGUỒN: " + source_context[:1000] + "\n\n"
-                "=== NGUỒN TIN ===\n" + source_context + "\n\n"
-                "=== YÊU CẦU VIẾT BÀI THEO SLIDE ===\n"
-                "Viết bài thành 5-6 ĐOẠN VĂN NGẮN, mỗi đoạn là 1 SLIDE.\n"
-                "\n"
-                "SLIDE 1 - MỞ ĐẦU: Giới thiệu chủ đề, nêu quan điểm cá nhân (2-4 câu hoàn chỉnh)\n"
-                "SLIDE 2-3-4-5 - PHÂN TÍCH: Mỗi slide dùng 1 nguồn tin cụ thể, kết hợp quan điểm cá nhân, ghi rõ nguồn (Theo VnExpress...), 2-4 câu hoàn chỉnh, thành 1 đoạn văn hoàn chỉnh\n"
-                "SLIDE 6 - KẾT LUẬN: Tổng kết quan điểm, nhận định cuối cùng (2-3 câu hoàn chỉnh)\n"
-                "\n"
-                "Định dạng:\n"
-                "---SLIDE 1---\n[đoạn văn hoàn chỉnh kết thúc bằng dấu chấm]\n---SLIDE 2---\n[đoạn văn hoàn chỉnh kết thúc bằng dấu chấm]\n...\n"
-                "\n"
-                "QUAN TRỌNG: Mỗi slide là 1 đoạn văn HOÀN CHỈNH, 2-4 câu, PHẢI KẾT THÚC BẰNG DẤU CHẤM (.). Kết hợp QUAN ĐIỂM + NGUỒN TIN. Không gạch đầu dòng. Viết liền mạch. 300-600 từ."
-            )
-            ai_text = None  # Không dùng AI, để code tự kết hợp opinion + source
-    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:
-        slides = []
-        # Parse từ AI output (format: ---SLIDE N---)
-        if ai_text:
-            pattern = r'---SLIDE\s*(\d+)---\s*\n(.*?)(?=---SLIDE|\Z)'
-            matches = re.findall(pattern, ai_text, re.DOTALL)
-            if matches:
-                for idx, (num, content) in enumerate(matches):
-                    # Normalize: ensure complete sentences
-                    text = _ensure_sentence_complete(content)
-                    if len(text) > 30:
-                        img = source_images[idx] if idx < len(source_images) else ""
-                        slides.append({"text": text, "image": img, "index": idx + 1})
-            
-            # Fallback: split by paragraphs
-            if len(slides) < 3:
-                paragraphs = [p.strip() for p in re.split(r'\n\n+', ai_text) if p.strip()]
-                slides = []
-                para_count = 0
-                for p in paragraphs:
-                    p = p.strip()
-                    if p.startswith('#') or p.startswith('---') or p.startswith('*Nguồn'):
-                        continue
-                    # Normalize: ensure complete sentences
-                    p_normalized = _ensure_sentence_complete(p)
-                    if len(p_normalized) > 50:
-                        img = source_images[para_count] if para_count < len(source_images) else ""
-                        slides.append({"text": p_normalized, "image": img, "index": para_count + 1})
-                        para_count += 1
-                        if para_count >= 6:
-                            break
-        
-        if len(slides) < 2:
-            slides = []
-            # Slide 1: QUAN ĐIỂM CÁ NHÂN (BẮT BUỘC)
-            slides.append({"text": f"Theo quan điểm cá nhân: {opinion[:400]}", "image": source_images[0] if source_images else "", "index": 1})
-            
-            # Slide 2-6: KẾT HỢP QUAN ĐIỂM + SOURCE
-            for i in range(min(5, len(source_details))):
-                if len(slides) >= 6:
-                    break
-                src = source_details[i]
-                src_via = src.get("via", "")
-                src_paras = src.get("paragraphs", [])
-                
-                src_text = ""
-                for p in src_paras[:2]:
-                    p = p.strip()[:280]
-                    if len(p) > 50:
-                        src_text = p
-                        break
-                
-                if src_text:
-                    combined = f"Theo góc nhìn cá nhân, {opinion[:60]}. Theo {src_via}: {src_text}"
-                    img = source_images[len(slides)] if len(slides) < len(source_images) else (source_images[-1] if source_images else "")
-                    slides.append({"text": _ensure_sentence_complete(combined), "image": img, "index": len(slides) + 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')
+        'en': ['sad', 'unhappy', 'terrible', 'awful', 'horrible', 'miserable', 'depressed