Update app.py

app.py

@@ -12,10 +12,11 @@ import threading
 from queue import Queue
 import logging
 from typing import Dict, List, Tuple, Optional
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Request, Form
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 import uvicorn
+import uuid
 
 # Enhanced logging configuration
 logging.basicConfig(
@@ -28,6 +29,11 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
+# Global storage for translation requests (WordPress integration)
+translation_requests = {}
+completed_translations = {}
+translation_requests_lock = threading.Lock()
+
 # Pydantic models for request/response
 class TranslationRequest(BaseModel):
     text: str
@@ -119,11 +125,11 @@ class TranslationQueue:
                     thread.start()
 
 class TextChunker:
-    """کلاس برای تقسیم متن طولانی به بخش‌های کوچکتر"""
+    """کلاس برای تقسیم متن طولانی به بخش‌های کوچک‌تر"""
     
     @staticmethod
     def split_text_smart(text: str, max_chunk_size: int = 400) -> List[str]:
-        """تقسیم هوشمند متن بر اساس جملات و پاراگراف‌ها"""
+        """تقسیم هوشمند متن بر اساس جملات و پاراگراف‌ها"""
         logger.info(f"[CHUNKER] Starting smart text splitting | Text length: {len(text)} chars | Max chunk size: {max_chunk_size}")
         
         if len(text) <= max_chunk_size:
@@ -132,27 +138,27 @@ class TextChunker:
         
         chunks = []
         
-        # تقسیم بر اساس پاراگراف‌ها
+        # تقسیم بر اساس پاراگراف‌ها
         paragraphs = text.split('\n\n')
         current_chunk = ""
         
         for i, paragraph in enumerate(paragraphs):
             logger.debug(f"[CHUNKER] Processing paragraph {i+1}/{len(paragraphs)} | Length: {len(paragraph)}")
             
-            # اگر پاراگراف خودش بزرگ است، آن را تقسیم کن
+            # اگر پاراگراف خودش بزرگ است آن را تقسیم کن
             if len(paragraph) > max_chunk_size:
-                # ذخیره قسمت فعلی اگر وجود دارد
+                # ذخیره قسمت فعلی اگر وجود دارد
                 if current_chunk.strip():
                     chunks.append(current_chunk.strip())
                     logger.debug(f"[CHUNKER] Added chunk from accumulated paragraphs | Length: {len(current_chunk.strip())}")
                     current_chunk = ""
                 
-                # تقسیم پاراگراف بزرگ
+                # تقسیم پاراگراف بزرگ
                 sub_chunks = TextChunker._split_paragraph(paragraph, max_chunk_size)
                 chunks.extend(sub_chunks)
                 logger.debug(f"[CHUNKER] Split large paragraph into {len(sub_chunks)} sub-chunks")
             else:
-                # بررسی اینکه آیا اضافه کردن این پاراگراف از حد تجاوز می‌کند
+                # بررسی اینکه آیا اضافه کردن این پاراگراف از حد تجاوز می‌کند
                 if len(current_chunk) + len(paragraph) + 2 > max_chunk_size:
                     if current_chunk.strip():
                         chunks.append(current_chunk.strip())
@@ -164,7 +170,7 @@ class TextChunker:
                     else:
                         current_chunk = paragraph
         
-        # اضافه کردن آخرین قسمت
+        # اضافه کردن آخرین قسمت
         if current_chunk.strip():
             chunks.append(current_chunk.strip())
             logger.debug(f"[CHUNKER] Added final chunk | Length: {len(current_chunk.strip())}")
@@ -174,10 +180,10 @@ class TextChunker:
     
     @staticmethod
     def _split_paragraph(paragraph: str, max_chunk_size: int) -> List[str]:
-        """تقسیم پاراگراف بزرگ به جملات"""
+        """تقسیم پاراگراف بزرگ به جملات"""
         logger.debug(f"[CHUNKER] Splitting large paragraph | Length: {len(paragraph)}")
         
-        # تقسیم بر اساس جملات
+        # تقسیم بر اساس جملات
         sentences = re.split(r'[.!?]+\s+', paragraph)
         chunks = []
         current_chunk = ""
@@ -186,12 +192,12 @@ class TextChunker:
             if not sentence.strip():
                 continue
                 
-            # اضافه کردن علامت نقطه اگر حذف شده
+            # اضافه کردن علامت نقطه اگر حذف شده
             if not sentence.endswith(('.', '!', '?')):
                 sentence += '.'
             
             if len(sentence) > max_chunk_size:
-                # جمله خودش خیلی بلند است - تقسیم بر اساس کاما
+                # جمله خودش خیلی بلند است - تقسیم بر اساس کاما
                 if current_chunk.strip():
                     chunks.append(current_chunk.strip())
                     current_chunk = ""
@@ -217,7 +223,7 @@ class TextChunker:
     
     @staticmethod
     def _split_by_comma(sentence: str, max_chunk_size: int) -> List[str]:
-        """تقسیم جمله طولانی بر اساس کاما"""
+        """تقسیم جمله طولانی بر اساس کاما"""
         logger.debug(f"[CHUNKER] Splitting long sentence by comma | Length: {len(sentence)}")
         
         parts = sentence.split(', ')
@@ -226,12 +232,12 @@ class TextChunker:
         
         for part in parts:
             if len(part) > max_chunk_size:
-                # قسمت خودش خیلی بلند است - تقسیم اجباری
+                # قسمت خودش خیلی بلند است - تقسیم اجباری
                 if current_chunk.strip():
                     chunks.append(current_chunk.strip())
                     current_chunk = ""
                 
-                # تقسیم اجباری بر اساس طول
+                # تقسیم اجباری بر اساس طول
                 while len(part) > max_chunk_size:
                     chunks.append(part[:max_chunk_size].strip())
                     part = part[max_chunk_size:].strip()
@@ -259,38 +265,6 @@ class MultilingualTranslator:
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         logger.info(f"[INIT] Using device: {self.device}")
         
-        # در متد __init__ کلاس MultilingualTranslator
-        self.translation_store = {}  # ذخیره‌سازی موقت ترجمه‌ها بر اساس request_id
-        self.request_mapping = {}    # mapping بین request_id و hash متن
-
-        # بعد از اتمام ترجمه موفق، در متد translate_text
-        # translation_result = {
-        #     'translation': final_translation,
-        #     'processing_time': processing_time,
-        #     'chunks_processed': len(chunks),
-        #     'source_lang': source_code,
-        #     'target_lang': target_code,
-        #     'timestamp': time.time()
-        # }
-        # self.translation_store[session_id] = translation_result
-
-        # متد برای پاک‌سازی خودکار داده‌های قدیمی
-        def cleanup_old_translations(self, max_age_hours: int = 24):
-            """پاک‌سازی ترجمه‌های قدیمی از ذخیره‌سازی"""
-            current_time = time.time()
-            keys_to_delete = []
-            
-            for request_id, data in self.translation_store.items():
-                if current_time - data['timestamp'] > max_age_hours * 3600:
-                    keys_to_delete.append(request_id)
-            
-            for key in keys_to_delete:
-                del self.translation_store[key]
-                if key in self.request_mapping:
-                    del self.request_mapping[key]
-            
-            logger.info(f"[CLEANUP] Removed {len(keys_to_delete)} old translations")
-
         # Initialize cache and queue
         self.cache = TranslationCache(cache_duration_minutes)
         self.queue = TranslationQueue()
@@ -314,9 +288,9 @@ class MultilingualTranslator:
             logger.error(f"[INIT] Error loading model: {e}")
             raise
         
-        # تنظیمات بهینه برای ترجمه متن‌های بلند
-        self.max_chunk_size = 350  # حداکثر طول هر قسمت
-        self.min_chunk_overlap = 20  # همپوشانی بین قسمت‌ها
+        # تنظیمات بهینه برای ترجمه متن‌های بلند
+        self.max_chunk_size = 350  # حداکثر طول هر قسمت
+        self.min_chunk_overlap = 20  # همپوشانی بین قسمت‌ها
         
         # Track translation progress
         self.current_translation = {}
@@ -325,9 +299,9 @@ class MultilingualTranslator:
         logger.info(f"[INIT] Translator initialized | Max chunk size: {self.max_chunk_size} chars")
     
     def translate_chunk(self, text: str, source_lang: str, target_lang: str, chunk_index: int = 0, total_chunks: int = 1) -> str:
-        """ترجمه یک قسمت کوچک از متن"""
+        """ترجمه یک قسمت کوچک از متن"""
         try:
-            logger.info(f"[TRANSLATE] Starting chunk translation [{chunk_index+1}/{total_chunks}] | {source_lang} → {target_lang} | Length: {len(text)} chars")
+            logger.info(f"[TRANSLATE] Starting chunk translation [{chunk_index+1}/{total_chunks}] | {source_lang} → {target_lang} | Length: {len(text)} chars")
             
             # Set source language for tokenizer
             self.tokenizer.src_lang = source_lang
@@ -341,15 +315,15 @@ class MultilingualTranslator:
             generated_tokens = self.model.generate(
                 **encoded,
                 forced_bos_token_id=self.tokenizer.get_lang_id(target_lang),
-                max_length=1024,  # افزایش طول خروجی
-                min_length=10,    # حداقل طول خروجی
-                num_beams=5,      # افزایش تعداد beam ها برای کیفیت بهتر
+                max_length=1024,  # افزایش طول خروجی
+                min_length=10,    # حداقل طول خروجی
+                num_beams=5,      # افزایش تعداد beam ها برای کیفیت بهتر
                 early_stopping=True,
-                no_repeat_ngram_size=3,  # جلوگیری از تکرار
-                length_penalty=1.0,      # تنظیم جریمه طول
-                repetition_penalty=1.2,  # جلوگیری از تکرار کلمات
-                do_sample=False,         # استفاده از روش قطعی
-                temperature=0.7,         # کنترل تنوع
+                no_repeat_ngram_size=3,  # جلوگیری از تکرار
+                length_penalty=1.0,      # تنظیم جریمه طول
+                repetition_penalty=1.2,  # جلوگیری از تکرار کلمات
+                do_sample=False,         # استفاده از روش قطعی
+                temperature=0.7,         # کنترل تنوع
                 pad_token_id=self.tokenizer.pad_token_id,
                 eos_token_id=self.tokenizer.eos_token_id
             )
@@ -358,7 +332,7 @@ class MultilingualTranslator:
             # Decode result
             translation = self.tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
             
-            # پاک‌سازی ترجمه از کاراکترهای اضافی
+            # پاک‌سازی ترجمه از کاراکترهای اضافی
             translation = translation.strip()
             
             logger.info(f"[TRANSLATE] Chunk translation completed [{chunk_index+1}/{total_chunks}] | Generation time: {generation_time:.2f}s | Output length: {len(translation)} chars")
@@ -370,7 +344,7 @@ class MultilingualTranslator:
             return f"[Translation Error: {str(e)}]"
     
     def translate_text(self, text: str, source_lang: str, target_lang: str, session_id: str = None) -> Tuple[str, float, int]:
-        
+        """ترجمه متن با پشتیبانی از متن‌های طولانی و لاگ‌های مفصل"""
         start_time = time.time()
         
         if not session_id:
@@ -382,16 +356,10 @@ class MultilingualTranslator:
         cached_result = self.cache.get(text, source_lang, target_lang)
         if cached_result:
             logger.info(f"[SESSION:{session_id}] Translation completed from cache | Time: {time.time() - start_time:.2f}s")
-            
-            # ذخیره نتیجه در translation_store برای رهگیری
-            if session_id and cached_result and not cached_result.startswith("Translation error"):
-                self.store_translation_result(session_id, cached_result, time.time() - start_time, 1)
-                self.request_mapping[session_id] = hashlib.md5(text.encode()).hexdigest()
-            
             return cached_result, time.time() - start_time, 1
         
         try:
-            # اگر متن کوتاه است، مستقیماً ترجمه کن
+            # اگر متن کوتاه است مستقیماً ترجمه کن
             if len(text) <= self.max_chunk_size:
                 logger.info(f"[SESSION:{session_id}] Processing as short text")
                 translation = self.translate_chunk(text, source_lang, target_lang, 0, 1)
@@ -401,14 +369,9 @@ class MultilingualTranslator:
                 processing_time = time.time() - start_time
                 logger.info(f"[SESSION:{session_id}] Short text translation completed | Total time: {processing_time:.2f}s")
                 
-                # ذخیره نتیجه در translation_store برای رهگیری
-                if session_id and translation and not translation.startswith("Translation error"):
-                    self.store_translation_result(session_id, translation, processing_time, 1)
-                    self.request_mapping[session_id] = hashlib.md5(text.encode()).hexdigest()
-                
                 return translation, processing_time, 1
             
-            # تقسیم متن طولانی به بخش‌های کوچکتر
+            # تقسیم متن طولانی به قسمت‌های کوچک‌تر
             logger.info(f"[SESSION:{session_id}] Processing as long text - starting chunking")
             chunks = TextChunker.split_text_smart(text, self.max_chunk_size)
             logger.info(f"[SESSION:{session_id}] Text split into {len(chunks)} chunks")
@@ -423,17 +386,17 @@ class MultilingualTranslator:
                     'target_lang': target_lang
                 }
             
-            # ترجمه هر بخش
+            # ترجمه هر قسمت
             translated_chunks = []
             for i, chunk in enumerate(chunks):
                 chunk_start_time = time.time()
                 logger.info(f"[SESSION:{session_id}] Starting chunk {i+1}/{len(chunks)} | Chunk length: {len(chunk)} chars")
                 
-                # بررسی کش برای هر بخش
+                # بررسی کش برای هر قسمت
                 chunk_translation = self.cache.get(chunk, source_lang, target_lang)
                 
                 if not chunk_translation:
-                    # تخمین زمان باقی‌مانده
+                    # Estimate remaining time
                     if i > 0:
                         elapsed_time = time.time() - start_time
                         avg_time_per_chunk = elapsed_time / i
@@ -441,7 +404,7 @@ class MultilingualTranslator:
                         logger.info(f"[SESSION:{session_id}] Progress: {i}/{len(chunks)} | Avg time per chunk: {avg_time_per_chunk:.1f}s | Estimated remaining: {estimated_remaining:.1f}s")
                     
                     chunk_translation = self.translate_chunk(chunk, source_lang, target_lang, i, len(chunks))
-                    # ذخیره بخش در کش
+                    # ذخیره قسمت در کش
                     self.cache.set(chunk, source_lang, target_lang, chunk_translation)
                     
                     chunk_time = time.time() - chunk_start_time
@@ -456,11 +419,11 @@ class MultilingualTranslator:
                     if session_id in self.current_translation:
                         self.current_translation[session_id]['completed_chunks'] = i + 1
                 
-                # کمی استراحت بین ترجمه‌ها برای جلوگیری از بارگذاری زیاد
+                # کمی استراحت بین ترجمه‌ها برای جلوگیری از بارذاری زیاد
                 if i < len(chunks) - 1:
                     time.sleep(0.1)
             
-            # ترکیب بخش‌های ترجمه شده
+            # ترکیب قسمت‌های ترجمه شده
             logger.info(f"[SESSION:{session_id}] Combining translated chunks")
             final_translation = self._combine_translations(translated_chunks, text)
             
@@ -468,12 +431,26 @@ class MultilingualTranslator:
             self.cache.set(text, source_lang, target_lang, final_translation)
             
             processing_time = time.time() - start_time
+            
+            # Mark as completed for WordPress integration
             logger.info(f"[SESSION:{session_id}] Long text translation completed | Total time: {processing_time:.2f}s | Chunks: {len(chunks)} | Final length: {len(final_translation)} chars")
             
-            # ذخیره نتیجه در translation_store برای رهگیری
-            if session_id and final_translation and not final_translation.startswith("Translation error"):
-                self.store_translation_result(session_id, final_translation, processing_time, len(chunks))
-                self.request_mapping[session_id] = hashlib.md5(text.encode()).hexdigest()
+            # Store in completed_translations for WordPress to check
+            with translation_requests_lock:
+                completed_translations[session_id] = {
+                    'translation': final_translation,
+                    'processing_time': processing_time,
+                    'character_count': len(text),
+                    'source_lang': source_lang,
+                    'target_lang': target_lang,
+                    'completed_at': datetime.now().isoformat(),
+                    'request_id': session_id,
+                    'status': 'completed'
+                }
+                
+                # Remove from processing requests if exists
+                if session_id in translation_requests:
+                    del translation_requests[session_id]
             
             # Clean up progress tracking
             with self.translation_lock:
@@ -487,7 +464,7 @@ class MultilingualTranslator:
             with self.translation_lock:
                 self.current_translation.pop(session_id, None)
             return f"Translation error: {str(e)}", time.time() - start_time, 0
-
+    
     def get_translation_progress(self, session_id: str) -> Dict:
         """Get current translation progress"""
         with self.translation_lock:
@@ -511,82 +488,9 @@ class MultilingualTranslator:
                 'estimated_remaining': estimated_remaining,
                 'progress_percentage': (progress['completed_chunks'] / progress['total_chunks']) * 100
             }
-    def get_translation_by_request_id(self, request_id: str) -> Dict:
-        """یافتن ترجمه کامل بر اساس request_id با پشتیبانی از کش"""
-        logger.info(f"[TRACKING] Looking up translation for request_id: {request_id}")
-        
-        # 1. اول در ترجمه‌های جاری بررسی کنیم
-        with self.translation_lock:
-            if request_id in self.current_translation:
-                progress = self.current_translation[request_id].copy()
-                logger.info(f"[TRACKING] Found active translation: {progress['completed_chunks']}/{progress['total_chunks']} chunks completed")
-                return {
-                    "status": "processing",
-                    "progress": progress,
-                    "translation": None,
-                    "found_in": "active_translations"
-                }
-        
-        # 2. بررسی در تسک‌های پس‌زمینه
-        if request_id in self.background_tasks:
-            task = self.background_tasks[request_id]
-            
-            if task.done():
-                try:
-                    translation, processing_time, chunks_count = task.result()
-                    logger.info(f"[TRACKING] Background task completed successfully: {len(translation)} chars")
-                    
-                    # حذف از تسک‌های پس‌زمینه
-                    del self.background_tasks[request_id]
-                    
-                    return {
-                        "status": "completed",
-                        "translation": translation,
-                        "processing_time": processing_time,
-                        "chunks_processed": chunks_count,
-                        "found_in": "background_tasks"
-                    }
-                except Exception as e:
-                    logger.error(f"[TRACKING] Background task failed: {str(e)}")
-                    del self.background_tasks[request_id]
-                    return {
-                        "status": "failed",
-                        "error": str(e),
-                        "found_in": "background_tasks"
-                    }
-            else:
-                logger.info(f"[TRACKING] Background task still running: {request_id}")
-                return {
-                    "status": "processing",
-                    "translation": None,
-                    "found_in": "background_tasks"
-                }
-        
-        # 3. بررسی در کش - این بخش نیاز به پیاده‌سازی سیستم رهگیری کش دارد
-        # برای این کار نیاز داریم که request_id را با متن اصلی مرتبط کنیم
-        # یک راه حل: ذخیره mapping بین request_id و hash متن
-        
-        # 4. بررسی در سیستم ذخیره‌سازی موقت (اگر پیاده‌سازی شده باشد)
-        if hasattr(self, 'translation_store') and request_id in self.translation_store:
-            result = self.translation_store[request_id]
-            logger.info(f"[TRACKING] Found in translation store: {len(result['translation'])} chars")
-            return {
-                "status": "completed",
-                "translation": result['translation'],
-                "processing_time": result['processing_time'],
-                "chunks_processed": result['chunks_processed'],
-                "found_in": "translation_store"
-            }
-        
-        logger.warning(f"[TRACKING] Request ID not found: {request_id}")
-        return {
-            "status": "not_found",
-            "message": "Translation request not found",
-            "found_in": None
-        }
-
+    
     def _combine_translations(self, translated_chunks: List[str], original_text: str) -> str:
-        """ترکیب قسمت‌های ترجمه شده به یک متن یکپارچه"""
+        """ترکیب قسمت‌های ترجمه شده به یک متن یکپارچه"""
         if not translated_chunks:
             return ""
         
@@ -595,23 +499,23 @@ class MultilingualTranslator:
         
         logger.debug(f"[COMBINER] Combining {len(translated_chunks)} translated chunks")
         
-        # ترکیب قسمت‌ها با در نظر گیری ساختار اصلی متن
+        # ترکیب قسمت‌ها با در نظر گیری ساختار اصلی متن
         combined = []
         
         for i, chunk in enumerate(translated_chunks):
-            # پاک‌سازی قسمت
+            # پاک‌سازی قسمت
             chunk = chunk.strip()
             
             if not chunk:
                 continue
             
-            # اضافه کردن فاصله مناسب بین قسمت‌ها
+            # اضافه کردن فاصله مناسب بین قسمت‌ها
             if i > 0 and combined:
-                # اگر قسمت قبلی با نقطه تمام نمی‌شود، نقطه اضافه کن
-                if not combined[-1].rstrip().endswith(('.', '!', '?', ':', 'Ø›', '.')):
+                # اگر قسمت قبلی با نقطه تمام نمی‌شود فاصله اضافه کن
+                if not combined[-1].rstrip().endswith(('.', '!', '?', ':', '۔', '.')):
                     combined[-1] += '.'
                 
-                # بررسی اینکه آیا نیاز به پاراگراف جدید داریم
+                # بررسی اینکه آیا نیاز به پاراگراف جدید دارکم
                 if '\n\n' in original_text:
                     combined.append('\n\n' + chunk)
                 else:
@@ -621,40 +525,14 @@ class MultilingualTranslator:
         
         result = ''.join(combined)
         
-        # پاک‌سازی نهایی
-        result = re.sub(r'\s+', ' ', result)  # حذف فاصله‌های اضافی
-        result = re.sub(r'\.+', '.', result)  # حذف نقطه‌های تکراری
+        # پاک‌سازی نهایی
+        result = re.sub(r'\s+', ' ', result)  # حذف فاصله‌های اضافی
+        result = re.sub(r'\.+', '.', result)  # حذف نقطه‌های تکراری
         result = result.strip()
         
         logger.debug(f"[COMBINER] Combined translation length: {len(result)} chars")
         return result
 
-    def cleanup_old_translations(self, max_age_hours: int = 24):
-        """پاک‌سازی ترجمه‌های قدیمی از ذخیره‌سازی"""
-        current_time = time.time()
-        keys_to_delete = []
-        
-        for request_id, data in self.translation_store.items():
-            if current_time - data['timestamp'] > max_age_hours * 3600:
-                keys_to_delete.append(request_id)
-        
-        for key in keys_to_delete:
-            del self.translation_store[key]
-            if key in self.request_mapping:
-                del self.request_mapping[key]
-        
-        logger.info(f"[CLEANUP] Removed {len(keys_to_delete)} old translations")
-    
-    def store_translation_result(self, request_id: str, translation: str, processing_time: float, chunks_processed: int):
-        """ذخیره نتیجه ترجمه برای دسترسی بعدی"""
-        self.translation_store[request_id] = {
-            'translation': translation,
-            'processing_time': processing_time,
-            'chunks_processed': chunks_processed,
-            'timestamp': time.time()
-        }
-        logger.info(f"[STORAGE] Stored translation for request_id: {request_id}")
-
     async def translate_text_async(self, text: str, source_lang: str, target_lang: str, session_id: str = None):
         """Async wrapper for translate_text"""
         loop = asyncio.get_event_loop()
@@ -664,6 +542,76 @@ class MultilingualTranslator:
             text, source_lang, target_lang, session_id
         )
 
+def process_heavy_translation_background(request_id: str, text: str, source_lang: str, target_lang: str):
+    """
+    Background function to process heavy text translations for WordPress integration.
+    Updates the completed_translations dict when done.
+    """
+    try:
+        logger.info(f"[HF Server] Background processing started for request: {request_id}")
+        
+        start_time = time.time()
+        
+        # Update progress in requests
+        with translation_requests_lock:
+            if request_id in translation_requests:
+                translation_requests[request_id]['progress'] = 10
+        
+        # Perform actual translation
+        translation, processing_time, chunks_count = translator.translate_text(
+            text, source_lang, target_lang, request_id
+        )
+        
+        processing_time = time.time() - start_time
+        
+        # Store completed translation
+        with translation_requests_lock:
+            completed_translations[request_id] = {
+                'translation': translation,
+                'processing_time': processing_time,
+                'character_count': len(text),
+                'source_lang': source_lang,
+                'target_lang': target_lang,
+                'completed_at': datetime.now().isoformat(),
+                'request_id': request_id,
+                'status': 'completed'
+            }
+            
+            # Remove from processing queue
+            if request_id in translation_requests:
+                del translation_requests[request_id]
+        
+        logger.info(f"[HF Server] Long text translation completed for request: {request_id} in {processing_time:.2f}s")
+        
+    except Exception as e:
+        logger.error(f"[HF Server] Background processing error for {request_id}: {str(e)}")
+        
+        # Mark as failed
+        with translation_requests_lock:
+            completed_translations[request_id] = {
+                'translation': '',
+                'error': str(e),
+                'status': 'failed',
+                'processing_time': time.time() - start_time if 'start_time' in locals() else 0,
+                'completed_at': datetime.now().isoformat(),
+                'request_id': request_id
+            }
+            
+            # Remove from processing queue
+            if request_id in translation_requests:
+                del translation_requests[request_id]
+
+def perform_translation_internal(text: str, source_lang: str, target_lang: str) -> str:
+    """
+    Internal translation function - wrapper for translator.translate_text
+    """
+    try:
+        translation, _, _ = translator.translate_text(text, source_lang, target_lang)
+        return translation
+    except Exception as e:
+        logger.error(f"[INTERNAL] Translation error: {str(e)}")
+        return f"Translation error: {str(e)}"
+
 # Language mappings for M2M100 model
 LANGUAGE_MAP = {
     "English": "en",
@@ -750,57 +698,140 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-@app.get("/")
-async def root():
-    return {
-        "message": "Enhanced Multilingual Translation API v2.1", 
-        "status": "active", 
-        "features": [
-            "enhanced_logging", 
-            "progress_tracking", 
-            "long_text_support", 
-            "smart_chunking", 
-            "cache_optimization"
-        ]
-    }
+# ========== NEW WORDPRESS INTEGRATION ENDPOINTS ==========
 
-@app.post("/api/translate")
-async def api_translate(request: TranslationRequest):
-    """API endpoint for translation with enhanced logging and progress tracking"""
-    if not request.text.strip():
-        raise HTTPException(status_code=400, detail="No text provided")
-    
-    source_code = LANGUAGE_MAP.get(request.source_lang)
-    target_code = LANGUAGE_MAP.get(request.target_lang)
-    
-    if not source_code or not target_code:
-        raise HTTPException(status_code=400, detail="Invalid language codes")
-    
+@app.post("/api/check-completion")
+async def check_completion(request: Request):
+    """
+    Endpoint to verify if a translation request has been completed.
+    WordPress calls this to confirm before charging credits.
+    """
     try:
-        # Generate session ID for tracking
-        session_id = hashlib.md5(f"{request.text[:100]}{time.time()}".encode()).hexdigest()[:8]
+        form_data = await request.form()
+        request_id = form_data.get('request_id', '').strip()
         
-        translation, processing_time, chunks_count = translator.translate_text(
-            request.text, source_code, target_code, session_id
-        )
+        if not request_id:
+            return {
+                'status': 'error',
+                'message': 'Request ID is required'
+            }
         
-        return TranslationResponse(
-            translation=translation,
-            source_language=request.source_lang,
-            target_language=request.target_lang,
-            processing_time=processing_time,
-            character_count=len(request.text),
-            status="success",
-            chunks_processed=chunks_count
-        )
+        logger.info(f"[HF Server] Completion verification requested for: {request_id}")
+        
+        with translation_requests_lock:
+            # Check if request exists in completed translations
+            if request_id in completed_translations:
+                completion_data = completed_translations[request_id]
+                
+                logger.info(f"[HF Server] Completion verification for {request_id}: COMPLETED")
+                
+                return {
+                    'status': 'completed',
+                    'request_id': request_id,
+                    'completed_at': completion_data.get('completed_at'),
+                    'processing_time': completion_data.get('processing_time', 0),
+                    'verified': True
+                }
+            
+            # Check if request is still processing
+            elif request_id in translation_requests:
+                logger.info(f"[HF Server] Completion verification for {request_id}: STILL PROCESSING")
+                
+                return {
+                    'status': 'processing',
+                    'request_id': request_id,
+                    'verified': False
+                }
+            
+            else:
+                logger.info(f"[HF Server] Completion verification for {request_id}: NOT FOUND")
+                
+                return {
+                    'status': 'not_found',
+                    'request_id': request_id,
+                    'message': 'Request ID not found'
+                }
+                
     except Exception as e:
-        logger.error(f"[API] Translation error: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Translation error: {str(e)}")
+        logger.error(f"[HF Server] Error in check_completion: {str(e)}")
+        return {
+            'status': 'error',
+            'message': 'Server error occurred'
+        }
+
+@app.post("/api/check-translation-status")
+async def check_translation_status(request: Request):
+    """
+    Endpoint to get the current status and result of a translation request.
+    Returns translation content if completed.
+    """
+    try:
+        form_data = await request.form()
+        request_id = form_data.get('request_id', '').strip()
+        
+        if not request_id:
+            return {
+                'status': 'error',
+                'message': 'Request ID is required'
+            }
+        
+        logger.info(f"[HF Server] Translation status check for: {request_id}")
+        
+        with translation_requests_lock:
+            # Check if translation is completed
+            if request_id in completed_translations:
+                result = completed_translations[request_id]
+                
+                logger.info(f"[HF Server] Translation status check for {request_id}: COMPLETED - returning translation")
+                
+                return {
+                    'status': 'completed',
+                    'request_id': request_id,
+                    'translation': result.get('translation', ''),
+                    'processing_time': result.get('processing_time', 0),
+                    'character_count': result.get('character_count', 0),
+                    'completed_at': result.get('completed_at'),
+                    'source_lang': result.get('source_lang', ''),
+                    'target_lang': result.get('target_lang', '')
+                }
+            
+            # Check if still processing
+            elif request_id in translation_requests:
+                req_data = translation_requests[request_id]
+                
+                logger.info(f"[HF Server] Translation status check for {request_id}: STILL PROCESSING")
+                
+                return {
+                    'status': 'processing',
+                    'request_id': request_id,
+                    'started_at': req_data.get('started_at'),
+                    'progress': req_data.get('progress', 0)
+                }
+            
+            else:
+                logger.info(f"[HF Server] Translation status check for {request_id}: NOT FOUND")
+                
+                return {
+                    'status': 'not_found',
+                    'request_id': request_id,
+                    'message': 'Translation request not found'
+                }
+                
+    except Exception as e:
+        logger.error(f"[HF Server] Error in check_translation_status: {str(e)}")
+        return {
+            'status': 'error',
+            'message': 'Server error occurred'
+        }
+
+# ========== UPDATED MAIN TRANSLATION ENDPOINT ==========
 
-# Alternative endpoint for form data (compatibility with WordPress)
 @app.post("/api/translate/form")
 async def api_translate_form(request: Request):
-    """Non-blocking translation endpoint with enhanced error handling"""
+    """
+    Enhanced translation endpoint that handles both short and long texts.
+    For long texts, returns immediately with request_id for background processing.
+    """
     try:
         form_data = await request.form()
         text = form_data.get("text", "")
@@ -815,13 +846,11 @@ async def api_translate_form(request: Request):
             target_lang = json_data.get("target_lang", "")
             api_key = json_data.get("api_key", None)
         except:
-            raise HTTPException(status_code=400, detail="Invalid request format")
-    
-    logger.info(f"[FORM API] Translation request | {source_lang} → {target_lang} | Length: {len(text)} chars")
+            return {"status": "error", "message": "Invalid request format"}
     
     if not text.strip():
         logger.error("[FORM API] No text provided")
-        return {"status": "error", "message": "No text provided"}
+        return {"status": "error", "message": "Text, source language, and target language are required"}
     
     source_code = LANGUAGE_MAP.get(source_lang)
     target_code = LANGUAGE_MAP.get(target_lang)
@@ -830,74 +859,143 @@ async def api_translate_form(request: Request):
         logger.error(f"[FORM API] Invalid language codes: {source_lang} -> {target_lang}")
         return {"status": "error", "message": "Invalid language codes"}
     
-    # Generate session ID for tracking
-    session_id = hashlib.md5(f"{text[:100]}{time.time()}".encode()).hexdigest()[:8]
+    char_count = len(text)
+    is_heavy_text = char_count > 1000  # Same threshold as WordPress
+    
+    logger.info(f"[FORM API] Translation request: {char_count} chars, {source_lang} → {target_lang}, Heavy: {is_heavy_text}")
     
-    # Check if it's a long text that should be processed in background
-    if len(text) > translator.max_chunk_size:
-        # 🔹 اول بررسی کن آیا نتیجه در کش وجود دارد یا نه
+    if is_heavy_text:
+        # Generate request ID for background processing
+        request_id = str(uuid.uuid4())
+        
+        # First check cache for immediate return
         cached_result = translator.cache.get(text, source_code, target_code)
         if cached_result:
-            logger.info(f"[FORM API] Returning cached translation immediately for session: {session_id}")
+            logger.info(f"[FORM API] Returning cached translation immediately for request: {request_id}")
             return {
                 "translation": cached_result,
                 "source_language": source_lang,
                 "target_language": target_lang,
                 "processing_time": 0.0,
-                "character_count": len(text),
+                "character_count": char_count,
                 "status": "success",
                 "chunks_processed": None,
-                "session_id": session_id,
-                "is_heavy_text": False,
+                "request_id": request_id,
                 "cached": True
             }
-        # 🔹 اگر در کش نبود → پس بفرست به background
-        task = asyncio.create_task(
-            translator.translate_text_async(text, source_code, target_code, session_id)
+        
+        # Store request for processing
+        with translation_requests_lock:
+            translation_requests[request_id] = {
+                'text': text,
+                'source_lang': source_code,
+                'target_lang': target_code,
+                'started_at': datetime.now().isoformat(),
+                'character_count': char_count,
+                'progress': 0
+            }
+        
+        # Start background processing
+        thread = threading.Thread(
+            target=process_heavy_translation_background,
+            args=(request_id, text, source_code, target_code)
         )
-        translator.background_tasks[session_id] = task
+        thread.daemon = True
+        thread.start()
         
-        logger.info(f"[FORM API] Started background translation for session: {session_id}")
+        logger.info(f"[FORM API] Started background processing for request: {request_id}")
         
         return {
-            "session_id": session_id,
-            "request_id": session_id,
-            "status": "processing",
-            "message": "Translation started in background. Use CHECK RESULT to get your translation.",
-            "character_count": len(text),
-            "is_background": True,
-            "is_heavy_text": True
+            'is_background': True,
+            'session_id': request_id,
+            'request_id': request_id,
+            'status': 'processing',
+            'message': f'Long text ({char_count} characters) is being processed in background. Use the request ID to check status.',
+            'character_count': char_count
         }
+    
     else:
         # Process short text immediately
         try:
-            translation, processing_time, chunks_count = await translator.translate_text_async(
-                text, source_code, target_code, session_id
+            start_time = time.time()
+            
+            translation, processing_time, chunks_count = translator.translate_text(
+                text, source_code, target_code
             )
             
-            # بررسی محتوای ترجمه
+            # Check translation content
             if not translation or not translation.strip() or translation.startswith("Translation error"):
                 logger.error(f"[FORM API] Invalid translation result: {translation[:100] if translation else 'None'}")
                 return {
                     "status": "error",
-                    "message": "Translation failed - empty or invalid result",
-                    "session_id": session_id
+                    "message": "Translation failed - empty or invalid result"
                 }
             
-            logger.info(f"[FORM API] Translation successful | Length: {len(translation)} chars")
+            logger.info(f"[FORM API] Short text translation completed in {processing_time:.2f}s")
+            
             return {
-                "translation": translation,
-                "source_language": source_lang,
-                "target_language": target_lang,
-                "processing_time": processing_time,
-                "character_count": len(text),
-                "status": "success",
-                "chunks_processed": chunks_count,
-                "session_id": session_id
+                'status': 'success',
+                'translation': translation,
+                'processing_time': processing_time,
+                'character_count': char_count,
+                'source_lang': source_lang,
+                'target_lang': target_lang
             }
+            
         except Exception as e:
             logger.error(f"[FORM API] Translation error: {str(e)}")
-            return {"status": "error", "message": f"Translation error: {str(e)}"}
+            return {"status": "error", "message": f"Translation failed: {str(e)}"}
+
+# ========== EXISTING ENDPOINTS (UPDATED) ==========
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Enhanced Multilingual Translation API v2.1 with WordPress Integration", 
+        "status": "active", 
+        "features": [
+            "enhanced_logging", 
+            "progress_tracking", 
+            "long_text_support", 
+            "smart_chunking", 
+            "cache_optimization",
+            "wordpress_integration",
+            "delayed_charging_support"
+        ]
+    }
+
+@app.post("/api/translate")
+async def api_translate(request: TranslationRequest):
+    """API endpoint for translation with enhanced logging and progress tracking"""
+    if not request.text.strip():
+        raise HTTPException(status_code=400, detail="No text provided")
+    
+    source_code = LANGUAGE_MAP.get(request.source_lang)
+    target_code = LANGUAGE_MAP.get(request.target_lang)
+    
+    if not source_code or not target_code:
+        raise HTTPException(status_code=400, detail="Invalid language codes")
+    
+    try:
+        # Generate session ID for tracking
+        session_id = hashlib.md5(f"{request.text[:100]}{time.time()}".encode()).hexdigest()[:8]
+        
+        translation, processing_time, chunks_count = translator.translate_text(
+            request.text, source_code, target_code, session_id
+        )
+        
+        return TranslationResponse(
+            translation=translation,
+            source_language=request.source_lang,
+            target_language=request.target_lang,
+            processing_time=processing_time,
+            character_count=len(request.text),
+            status="success",
+            chunks_processed=chunks_count
+        )
+    except Exception as e:
+        logger.error(f"[API] Translation error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Translation error: {str(e)}")
 
 @app.get("/api/progress/{session_id}")
 async def get_translation_progress(session_id: str):
@@ -923,6 +1021,10 @@ async def get_languages():
 @app.get("/api/health")
 async def health_check():
     """Health check endpoint"""
+    with translation_requests_lock:
+        active_requests = len(translation_requests)
+        completed_cache = len(completed_translations)
+    
     return {
         "status": "healthy",
         "device": str(translator.device),
@@ -930,6 +1032,8 @@ async def health_check():
         "cache_size": len(translator.cache.cache),
         "max_chunk_size": translator.max_chunk_size,
         "active_translations": len(translator.current_translation),
+        "active_requests": active_requests,
+        "completed_cache": completed_cache,
         "version": "2.1.0"
     }
 
@@ -995,9 +1099,12 @@ async def get_session_status(session_id: str):
 
 @app.get("/api/server-status")
 async def get_server_status():
-    """Get current server status - non-blocking"""
+    """Get current server status - enhanced for WordPress integration"""
     active_sessions = []
-    background_tasks_count = len(translator.background_tasks)
+    
+    with translation_requests_lock:
+        background_tasks_count = len(translation_requests)
+        completed_count = len(completed_translations)
     
     with translator.translation_lock:
         for session_id, progress in translator.current_translation.items():
@@ -1020,10 +1127,12 @@ async def get_server_status():
                 'estimated_remaining': estimated_remaining
             })
     
-    if active_sessions or background_tasks_count > 0:
+    total_active = len(active_sessions) + background_tasks_count
+    
+    if total_active > 0:
         if active_sessions:
             latest_session = active_sessions[-1]
-            message = f"Processing chunk {latest_session['completed_chunks']}/{latest_session['total_chunks']} | {latest_session['source_lang']} → {latest_session['target_lang']}"
+            message = f"Processing chunk {latest_session['completed_chunks']}/{latest_session['total_chunks']} | {latest_session['source_lang']} → {latest_session['target_lang']}"
         else:
             message = f"{background_tasks_count} translation(s) in background queue"
             
@@ -1033,7 +1142,8 @@ async def get_server_status():
             "message": message,
             "active_sessions": len(active_sessions),
             "background_tasks": background_tasks_count,
-            "total_active": len(active_sessions) + background_tasks_count
+            "total_active": total_active,
+            "completed_cache": completed_count
         }
     else:
         return {
@@ -1041,261 +1151,65 @@ async def get_server_status():
             "status": "idle",
             "message": "Server is ready for new translations",
             "active_sessions": 0,
-            "background_tasks": 0
-        }
-    
-    if active_sessions:
-        # Return the most recent active session
-        latest_session = active_sessions[-1]
-        return {
-            "has_active_translation": True,
-            "status": "processing",
-            "message": f"Processing chunk {latest_session['completed_chunks']}/{latest_session['total_chunks']} | {latest_session['source_lang']} → {latest_session['target_lang']}",
-            "session_data": latest_session
-        }
-    else:
-        return {
-            "has_active_translation": False,
-            "status": "no_active_translation",
-            "message": "No active translation on server"
+            "background_tasks": 0,
+            "completed_cache": completed_count
         }
 
-@app.post("/api/confirm-completion")
-async def confirm_completion_and_charge(request: Request):
-    """Endpoint برای تأیید تکمیل ترجمه و کسر اعتبار"""
-    try:
-        data = await request.json()
-        session_id = data.get("session_id")
-        request_id = data.get("request_id")
-        
-        if not session_id and not request_id:
-            raise HTTPException(status_code=400, detail="Session ID or Request ID required")
-        
-        # استفاده از session_id یا request_id برای یافتن ترجمه
-        identifier = session_id or request_id
-        
-        # بررسی وضعیت ترجمه
-        if identifier in translator.background_tasks:
-            task = translator.background_tasks[identifier]
-            
-            if task.done():
-                try:
-                    translation, processing_time, chunks_count = await task
-                    
-                    # حذف تسک از لیست تسک‌های پس‌زمینه
-                    del translator.background_tasks[identifier]
-                    
-                    return {
-                        "status": "completed",
-                        "translation": translation,
-                        "processing_time": processing_time,
-                        "chunks_processed": chunks_count,
-                        "confirmed": True,
-                        "message": "Translation completed and ready for charging"
-                    }
-                except Exception as e:
-                    del translator.background_tasks[identifier]
-                    return {
-                        "status": "failed",
-                        "confirmed": False,
-                        "message": f"Translation failed: {str(e)}"
-                    }
-            else:
-                return {
-                    "status": "processing",
-                    "confirmed": False,
-                    "message": "Translation still in progress"
-                }
-        
-        # بررسی در ترجمه‌های جاری
-        progress = translator.get_translation_progress(identifier)
-        if progress:
-            return {
-                "status": "processing",
-                "confirmed": False,
-                "message": f"Processing chunk {progress['completed_chunks']}/{progress['total_chunks']}",
-                "progress": progress
-            }
-        
-        # بررسی در کش (اگر ترجمه کامل شده باشد)
-        # این بخش نیاز به پیاده سازی دارد تا ترجمه‌های کامل شده را بر اساس شناسه برگرداند
-        
-        return {
-            "status": "not_found",
-            "confirmed": False,
-            "message": "Translation session not found"
-        }
-        
-    except Exception as e:
-        logger.error(f"[CONFIRM API] Error: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Confirmation error: {str(e)}")
+# ========== CLEANUP AND MAINTENANCE FUNCTIONS ==========
 
-@app.post("/api/check-translation-status")
-async def check_translation_status(request: Request):
-    """بررسی کامل وضعیت ترجمه برای کسر اعتبار"""
-    try:
-        data = await request.json()
-        request_id = data.get("request_id")
-        
-        if not request_id:
-            raise HTTPException(status_code=400, detail="Request ID required")
-        
-        logger.info(f"[STATUS CHECK] Checking status for request_id: {request_id}")
-        
-        # استفاده از متد کامل رهگیری
-        status_info = translator.get_translation_by_request_id(request_id)
-        
-        if status_info['status'] == 'completed':
-            # ترجمه کامل شده - آماد�� برای کسر اعتبار
-            return {
-                "status": "completed",
-                "completed": True,
-                "translation": status_info['translation'],
-                "processing_time": status_info.get('processing_time', 0),
-                "chunks_processed": status_info.get('chunks_processed', 0),
-                "ready_for_charging": True,
-                "message": "Translation completed successfully"
-            }
-        
-        elif status_info['status'] == 'processing':
-            # هنوز در حال پردازش
-            progress = status_info.get('progress', {})
-            return {
-                "status": "processing",
-                "completed": False,
-                "ready_for_charging": False,
-                "message": f"Processing: {progress.get('completed_chunks', 0)}/{progress.get('total_chunks', 0)} chunks",
-                "progress_percentage": progress.get('progress_percentage', 0)
-            }
-        
-        elif status_info['status'] == 'failed':
-            # خطا در ترجمه
-            return {
-                "status": "failed",
-                "completed": False,
-                "ready_for_charging": False,
-                "message": status_info.get('error', 'Translation failed')
-            }
-        
-        else:
-            # یافت نشد
-            return {
-                "status": "not_found",
-                "completed": False,
-                "ready_for_charging": False,
-                "message": "Translation request not found"
-            }
-            
-    except Exception as e:
-        logger.error(f"[STATUS CHECK] Error: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Status check error: {str(e)}")
-
-@app.post("/api/check-completion")
-async def check_completion_status(request: Request):
-    """بررسی وضعیت تکمیل ترجمه برای کسر اعتبار"""
-    try:
-        data = await request.json()
-        request_id = data.get("request_id")
-        
-        if not request_id:
-            raise HTTPException(status_code=400, detail="Request ID required")
-        
-        # اینجا باید منطق بررسی وضعیت ترجمه بر اساس request_id پیاده‌سازی شود
-        # برای سادگی، فرض می‌کنیم که اگر request_id در background_tasks وجود دارد،
-        # ولی تسک کامل شده، می‌توانیم وضعیت completed را برگردانیم
-        
-        if request_id in translator.background_tasks:
-            task = translator.background_tasks[request_id]
-            
-            if task.done():
-                try:
-                    translation, processing_time, chunks_count = await task
-                    return {
-                        "status": "completed",
-                        "completed": True,
-                        "message": "Translation completed successfully"
-                    }
-                except Exception as e:
-                    return {
-                        "status": "failed",
-                        "completed": False,
-                        "message": f"Translation failed: {str(e)}"
-                    }
-            else:
-                return {
-                    "status": "processing",
-                    "completed": False,
-                    "message": "Translation in progress"
-                }
-        
-        # اگر در background_tasks نیست، ممکن است در حال پردازش باشد یا کامل شده
-        progress = translator.get_translation_progress(request_id)
-        if progress:
-            return {
-                "status": "processing",
-                "completed": False,
-                "message": f"Processing in progress: {progress['completed_chunks']}/{progress['total_chunks']} chunks"
-            }
-        
-        # بررسی آیا قبلاً کامل شده و در کش ذخیره شده
-        # این بخش نیاز به پیاده‌سازی دارد
-        
-        return {
-            "status": "unknown",
-            "completed": False,
-            "message": "Request ID not found in active translations"
-        }
-        
-    except Exception as e:
-        logger.error(f"[COMPLETION CHECK] Error: {str(e)}")
-        return {
-            "status": "error",
-            "completed": False,
-            "message": f"Error checking completion: {str(e)}"
-        }
+def cleanup_old_requests():
+    """
+    Clean up old completed translations and stuck processing requests.
+    Should be called periodically.
+    """
+    current_time = datetime.now()
+    
+    with translation_requests_lock:
+        # Clean completed translations older than 2 hours
+        to_remove_completed = []
+        for req_id, data in completed_translations.items():
+            try:
+                completed_time = datetime.fromisoformat(data.get('completed_at', ''))
+                if (current_time - completed_time).total_seconds() > 7200:  # 2 hours
+                    to_remove_completed.append(req_id)
+            except:
+                to_remove_completed.append(req_id)  # Remove invalid entries
+        
+        for req_id in to_remove_completed:
+            del completed_translations[req_id]
+        
+        # Clean stuck processing requests older than 1 hour
+        to_remove_processing = []
+        for req_id, data in translation_requests.items():
+            try:
+                started_time = datetime.fromisoformat(data.get('started_at', ''))
+                if (current_time - started_time).total_seconds() > 3600:  # 1 hour
+                    to_remove_processing.append(req_id)
+            except:
+                to_remove_processing.append(req_id)  # Remove invalid entries
+        
+        for req_id in to_remove_processing:
+            del translation_requests[req_id]
+    
+    logger.info(f"[HF Server] Cleanup: Removed {len(to_remove_completed)} completed, {len(to_remove_processing)} stuck requests")
+    return len(to_remove_completed), len(to_remove_processing)
 
-@app.post("/api/notify-completion")
-async def notify_translation_completion(request: Request):
-    """Endpoint برای اطلاع‌رسانی خودکار تکمیل ترجمه به وردپرس"""
-    try:
-        data = await request.json()
-        request_id = data.get("request_id")
-        translation = data.get("translation")
-        processing_time = data.get("processing_time", 0)
-        
-        if not request_id or not translation:
-            raise HTTPException(status_code=400, detail="Request ID and translation required")
-        
-        logger.info(f"[NOTIFY] Translation completed for request_id: {request_id}")
-        
-        # اینجا باید به وردپرس اطلاع دهید که ترجمه کامل شده
-        # می‌توانید از webhook یا درخواست HTTP به وردپرس استفاده کنید
-        
-        # مثال: ارسال درخواست به وردپرس
-        wp_url = "https://your-wordpress-site.com/wp-admin/admin-ajax.php"
-        payload = {
-            'action': 'amt_completion_notification',
-            'request_id': request_id,
-            'translation': translation,
-            'processing_time': processing_time,
-            'secret_key': 'your_secret_key_here'  # برای امنیت
-        }
-        
+# Schedule periodic cleanup (runs every hour)
+def periodic_cleanup():
+    """Run cleanup every hour"""
+    while True:
+        time.sleep(3600)  # 1 hour
         try:
-            async with aiohttp.ClientSession() as session:
-                async with session.post(wp_url, data=payload) as response:
-                    if response.status == 200:
-                        logger.info(f"[NOTIFY] Successfully notified WordPress for request_id: {request_id}")
-                    else:
-                        logger.warning(f"[NOTIFY] WordPress notification failed: {response.status}")
+            cleanup_old_requests()
         except Exception as e:
-            logger.error(f"[NOTIFY] Error notifying WordPress: {str(e)}")
-        
-        return {"status": "success", "message": "Notification sent"}
-        
-    except Exception as e:
-        logger.error(f"[NOTIFY] Error: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Notification error: {str(e)}")
-        
+            logger.error(f"[CLEANUP] Error during periodic cleanup: {e}")
+
+# Start cleanup thread
+cleanup_thread = threading.Thread(target=periodic_cleanup, daemon=True)
+cleanup_thread.start()
+
+# ========== SERVER STARTUP ==========
+
 if __name__ == "__main__":
+    logger.info("[HF Server] Starting Enhanced Multilingual Translation API with WordPress Integration")
     uvicorn.run(app, host="0.0.0.0", port=7860)