Update app.py

app.py

@@ -1,47 +1,40 @@
-# server.py
 import asyncio
 from concurrent.futures import ThreadPoolExecutor
 import threading
+import torch
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 import time
 import json
 import hashlib
 import re
 from datetime import datetime, timedelta
+import threading
 from queue import Queue
 import logging
-from typing import Dict, List, Tuple, Optional, Any
-from fastapi import FastAPI, HTTPException, Request
+from typing import Dict, List, Tuple, Optional
+from fastapi import FastAPI, HTTPException, Request, Form
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 import uvicorn
-import os
-
-# Optional: Transformers (if you want local model)
-# If you don't plan to run a local transformer, you can still keep API and adapt.
-try:
-    from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
-    TRANSFORMERS_AVAILABLE = True
-except Exception:
-    TRANSFORMERS_AVAILABLE = False
-
-# ----------------------- Configuration -----------------------
-LOG_FILE = os.environ.get("TRANSLATION_LOG", "translation.log")
-HF_MODEL = os.environ.get("HF_MODEL", "facebook/m2m100_418M")  # change to 1.2B if you have resources
-MAX_WORKERS = int(os.environ.get("MAX_WORKERS", "3"))
-CACHE_MINUTES = int(os.environ.get("CACHE_MINUTES", "60"))
-MAX_CHUNK_SIZE = int(os.environ.get("MAX_CHUNK_SIZE", "350"))
-SERVER_HOST = os.environ.get("SERVER_HOST", "0.0.0.0")
-SERVER_PORT = int(os.environ.get("SERVER_PORT", "7860"))
-
-# ----------------------- Logging -----------------------
+import uuid
+
+# Enhanced logging configuration
 logging.basicConfig(
     level=logging.INFO,
-    format="%(asctime)s - %(levelname)s - %(message)s",
-    handlers=[logging.StreamHandler(), logging.FileHandler(LOG_FILE)]
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler('translation.log')
+    ]
 )
-logger = logging.getLogger("translator-server")
+logger = logging.getLogger(__name__)
+
+# Global storage for translation requests (WordPress integration)
+translation_requests = {}
+completed_translations = {}
+translation_requests_lock = threading.Lock()
 
-# ----------------------- Pydantic Models -----------------------
+# Pydantic models for request/response
 class TranslationRequest(BaseModel):
     text: str
     source_lang: str
@@ -59,13 +52,592 @@ class TranslationResponse(BaseModel):
     estimated_time_remaining: Optional[float] = None
     current_chunk: Optional[int] = None
     total_chunks: Optional[int] = None
-    session_id: Optional[str] = None
 
-# ----------------------- Language Map -----------------------
+class TranslationCache:
+    def __init__(self, cache_duration_minutes: int = 60):
+        self.cache = {}
+        self.cache_duration = timedelta(minutes=cache_duration_minutes)
+        self.lock = threading.Lock()
+    
+    def _generate_key(self, text: str, source_lang: str, target_lang: str) -> str:
+        """Generate cache key from text and languages"""
+        content = f"{text}_{source_lang}_{target_lang}"
+        return hashlib.md5(content.encode()).hexdigest()
+    
+    def get(self, text: str, source_lang: str, target_lang: str) -> str:
+        """Get translation from cache if exists and not expired"""
+        with self.lock:
+            key = self._generate_key(text, source_lang, target_lang)
+            if key in self.cache:
+                translation, timestamp = self.cache[key]
+                if datetime.now() - timestamp < self.cache_duration:
+                    logger.info(f"[CACHE HIT] Retrieved cached translation for key: {key[:8]}... | Length: {len(translation)} chars")
+                    return translation
+                else:
+                    # Remove expired entry
+                    del self.cache[key]
+                    logger.info(f"[CACHE EXPIRED] Removed expired cache entry for key: {key[:8]}...")
+            logger.info(f"[CACHE MISS] No cached translation found for key: {key[:8]}...")
+            return None
+    
+    def set(self, text: str, source_lang: str, target_lang: str, translation: str):
+        """Store translation in cache"""
+        with self.lock:
+            key = self._generate_key(text, source_lang, target_lang)
+            self.cache[key] = (translation, datetime.now())
+            logger.info(f"[CACHE STORE] Cached translation for key: {key[:8]}... | Translation length: {len(translation)} chars")
+
+class TranslationQueue:
+    def __init__(self, max_workers: int = 3):
+        self.queue = Queue()
+        self.max_workers = max_workers
+        self.current_workers = 0
+        self.lock = threading.Lock()
+    
+    def add_task(self, task_func, *args, **kwargs):
+        """Add translation task to queue"""
+        self.queue.put((task_func, args, kwargs))
+        logger.info(f"[QUEUE] Added task to queue | Queue size: {self.queue.qsize()}")
+    
+    def process_queue(self):
+        """Process tasks from queue"""
+        while not self.queue.empty():
+            with self.lock:
+                if self.current_workers >= self.max_workers:
+                    time.sleep(0.1)
+                    continue
+                
+                if not self.queue.empty():
+                    task_func, args, kwargs = self.queue.get()
+                    self.current_workers += 1
+                    logger.info(f"[QUEUE] Starting worker | Current workers: {self.current_workers}")
+                    
+                    def worker():
+                        try:
+                            result = task_func(*args, **kwargs)
+                            return result
+                        finally:
+                            with self.lock:
+                                self.current_workers -= 1
+                                logger.info(f"[QUEUE] Worker finished | Current workers: {self.current_workers}")
+                    
+                    thread = threading.Thread(target=worker)
+                    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:
+            logger.info(f"[CHUNKER] Text is small, no chunking needed | Length: {len(text)}")
+            return [text]
+        
+        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())
+                        logger.debug(f"[CHUNKER] Added chunk | Length: {len(current_chunk.strip())}")
+                    current_chunk = paragraph
+                else:
+                    if current_chunk:
+                        current_chunk += "\n\n" + paragraph
+                    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())}")
+        
+        logger.info(f"[CHUNKER] Text splitting completed | Total chunks: {len(chunks)} | Average chunk size: {sum(len(c) for c in chunks) / len(chunks):.1f} chars")
+        return chunks
+    
+    @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 = ""
+        
+        for sentence in sentences:
+            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 = ""
+                
+                sub_chunks = TextChunker._split_by_comma(sentence, max_chunk_size)
+                chunks.extend(sub_chunks)
+            else:
+                if len(current_chunk) + len(sentence) + 1 > max_chunk_size:
+                    if current_chunk.strip():
+                        chunks.append(current_chunk.strip())
+                    current_chunk = sentence
+                else:
+                    if current_chunk:
+                        current_chunk += " " + sentence
+                    else:
+                        current_chunk = sentence
+        
+        if current_chunk.strip():
+            chunks.append(current_chunk.strip())
+        
+        logger.debug(f"[CHUNKER] Paragraph split into {len(chunks)} sentence chunks")
+        return chunks
+    
+    @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(', ')
+        chunks = []
+        current_chunk = ""
+        
+        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()
+                
+                if part:
+                    current_chunk = part
+            else:
+                if len(current_chunk) + len(part) + 2 > max_chunk_size:
+                    if current_chunk.strip():
+                        chunks.append(current_chunk.strip())
+                    current_chunk = part
+                else:
+                    if current_chunk:
+                        current_chunk += ", " + part
+                    else:
+                        current_chunk = part
+        
+        if current_chunk.strip():
+            chunks.append(current_chunk.strip())
+        
+        return chunks
+
+class MultilingualTranslator:
+    def __init__(self, cache_duration_minutes: int = 60):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        logger.info(f"[INIT] Using device: {self.device}")
+        
+        # Initialize cache and queue
+        self.cache = TranslationCache(cache_duration_minutes)
+        self.queue = TranslationQueue()
+        
+        # Add thread pool for parallel processing
+        self.executor = ThreadPoolExecutor(max_workers=3)
+        self.background_tasks = {}
+        
+        logger.info(f"[INIT] Thread pool initialized with 3 workers")
+
+        # Load model - using a powerful multilingual model
+        self.model_name = "facebook/m2m100_1.2B"
+        logger.info(f"[INIT] Loading model: {self.model_name}")
+        
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name)
+            self.model.to(self.device)
+            logger.info(f"[INIT] Model loaded successfully on {self.device}!")
+        except Exception as e:
+            logger.error(f"[INIT] Error loading model: {e}")
+            raise
+        
+        # تنظیمات بهینه برای ترجمه متن‌های بلند
+        self.max_chunk_size = 350  # حداکثر طول هر قسمت
+        self.min_chunk_overlap = 20  # همپوشانی بین قسمت‌ها
+        
+        # Track translation progress
+        self.current_translation = {}
+        self.translation_lock = threading.Lock()
+        
+        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")
+            
+            # Set source language for tokenizer
+            self.tokenizer.src_lang = source_lang
+            
+            # Encode input
+            encoded = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512).to(self.device)
+            logger.debug(f"[TRANSLATE] Text encoded | Input tokens: {encoded.input_ids.shape[1]}")
+            
+            # Generate translation with optimized parameters
+            start_time = time.time()
+            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 ها برای کیفیت بهتر
+                early_stopping=True,
+                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
+            )
+            generation_time = time.time() - start_time
+            
+            # 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")
+            
+            return translation
+            
+        except Exception as e:
+            logger.error(f"[TRANSLATE] Chunk translation error [{chunk_index+1}/{total_chunks}]: {e}")
+            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:
+            session_id = hashlib.md5(f"{text[:100]}{time.time()}".encode()).hexdigest()[:8]
+        
+        logger.info(f"[SESSION:{session_id}] Starting translation | {source_lang} → {target_lang} | Text length: {len(text)} chars")
+        
+        # بررسی کش برای کل متن
+        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")
+            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)
+                
+                # ذخیره در کش
+                self.cache.set(text, source_lang, target_lang, translation)
+                processing_time = time.time() - start_time
+                logger.info(f"[SESSION:{session_id}] Short text translation completed | Total time: {processing_time:.2f}s")
+                
+                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")
+            
+            # Initialize progress tracking
+            with self.translation_lock:
+                self.current_translation[session_id] = {
+                    'total_chunks': len(chunks),
+                    'completed_chunks': 0,
+                    'start_time': start_time,
+                    'source_lang': source_lang,
+                    '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
+                        estimated_remaining = avg_time_per_chunk * (len(chunks) - i)
+                        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
+                    logger.info(f"[SESSION:{session_id}] Chunk {i+1}/{len(chunks)} translated in {chunk_time:.2f}s")
+                else:
+                    logger.info(f"[SESSION:{session_id}] Chunk {i+1}/{len(chunks)} retrieved from cache")
+                
+                translated_chunks.append(chunk_translation)
+                
+                # Update progress
+                with self.translation_lock:
+                    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)
+            
+            # ذخیره نتیجه نهایی در کش
+            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")
+            
+            # 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:
+                self.current_translation.pop(session_id, None)
+            
+            return final_translation, processing_time, len(chunks)
+            
+        except Exception as e:
+            logger.error(f"[SESSION:{session_id}] Translation error: {e}")
+            # Clean up progress tracking
+            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:
+            if session_id not in self.current_translation:
+                return None
+            
+            progress = self.current_translation[session_id].copy()
+            elapsed_time = time.time() - progress['start_time']
+            
+            if progress['completed_chunks'] > 0:
+                avg_time_per_chunk = elapsed_time / progress['completed_chunks']
+                remaining_chunks = progress['total_chunks'] - progress['completed_chunks']
+                estimated_remaining = avg_time_per_chunk * remaining_chunks
+            else:
+                estimated_remaining = None
+            
+            return {
+                'total_chunks': progress['total_chunks'],
+                'completed_chunks': progress['completed_chunks'],
+                'elapsed_time': elapsed_time,
+                'estimated_remaining': estimated_remaining,
+                'progress_percentage': (progress['completed_chunks'] / progress['total_chunks']) * 100
+            }
+    
+    def _combine_translations(self, translated_chunks: List[str], original_text: str) -> str:
+        """ترکیب قسمت‌های ترجمه شده به یک متن یکپارچه"""
+        if not translated_chunks:
+            return ""
+        
+        if len(translated_chunks) == 1:
+            return translated_chunks[0]
+        
+        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(('.', '!', '?', ':', 'Û”', '.')):
+                    combined[-1] += '.'
+                
+                # بررسی اینکه آیا نیاز به پاراگراف جدید دارکم
+                if '\n\n' in original_text:
+                    combined.append('\n\n' + chunk)
+                else:
+                    combined.append(' ' + chunk)
+            else:
+                combined.append(chunk)
+        
+        result = ''.join(combined)
+        
+        # پاک‌سازی نهایی
+        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
+
+    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()
+        return await loop.run_in_executor(
+            self.executor, 
+            self.translate_text, 
+            text, source_lang, target_lang, session_id
+        )
+
+def process_heavy_translation_background(request_id: str, text: str, source_lang: str, target_lang: str):
+    """
+    FIXED: Background function with better error handling and status updates
+    """
+    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
+                translation_requests[request_id]['status'] = 'processing'
+        
+        # Perform actual translation
+        translation, processing_time, chunks_count = translator.translate_text(
+            text, source_lang, target_lang, request_id
+        )
+        
+        total_processing_time = time.time() - start_time
+        
+        # FIXED: Validate translation result
+        if not translation or not translation.strip():
+            logger.error(f"[HF Server] Empty translation result for request: {request_id}")
+            
+            # Store failed translation
+            with translation_requests_lock:
+                completed_translations[request_id] = {
+                    'translation': '',
+                    'error': 'Translation completed but result is empty',
+                    'status': 'failed',
+                    'processing_time': total_processing_time,
+                    'completed_at': datetime.now().isoformat(),
+                    'request_id': request_id
+                }
+                
+                if request_id in translation_requests:
+                    del translation_requests[request_id]
+            return
+        
+        # Store completed translation
+        with translation_requests_lock:
+            completed_translations[request_id] = {
+                'translation': translation,
+                'processing_time': total_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',
+                'chunks_processed': chunks_count,
+                'source_lang_display': translation_requests[request_id].get('source_lang_display', source_lang),
+                'target_lang_display': translation_requests[request_id].get('target_lang_display', target_lang)
+            }
+            
+            # Remove from processing queue
+            if request_id in translation_requests:
+                del translation_requests[request_id]
+        
+        logger.info(f"[HF Server] Heavy text translation completed for request: {request_id} in {total_processing_time:.2f}s with {len(translation)} chars")
+        
+    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",
-    "Persian (Farsi)": "fa",
-    "Persian": "fa",
+    "Persian (Farsi)": "fa", 
     "Arabic": "ar",
     "French": "fr",
     "German": "de",
@@ -74,7 +646,6 @@ LANGUAGE_MAP = {
     "Portuguese": "pt",
     "Russian": "ru",
     "Chinese (Simplified)": "zh",
-    "Chinese": "zh",
     "Japanese": "ja",
     "Korean": "ko",
     "Hindi": "hi",
@@ -134,676 +705,551 @@ LANGUAGE_MAP = {
     "Zulu": "zu"
 }
 
-# ----------------------- Helpers -----------------------
-def generate_session_id(prefix: str = "") -> str:
-    return hashlib.md5(f"{prefix}_{time.time()}_{os.urandom(8)}".encode()).hexdigest()[:12]
-
-# ----------------------- Cache -----------------------
-class TranslationCache:
-    def __init__(self, cache_duration_minutes: int = CACHE_MINUTES):
-        self.cache: Dict[str, Tuple[str, datetime]] = {}
-        self.cache_duration = timedelta(minutes=cache_duration_minutes)
-        self.lock = threading.Lock()
-
-    def _generate_key(self, text: str, source_lang: str, target_lang: str) -> str:
-        content = f"{text}__{source_lang}__{target_lang}"
-        return hashlib.sha256(content.encode()).hexdigest()
-
-    def get(self, text: str, source_lang: str, target_lang: str) -> Optional[str]:
-        with self.lock:
-            key = self._generate_key(text, source_lang, target_lang)
-            entry = self.cache.get(key)
-            if entry:
-                translation, ts = entry
-                if datetime.utcnow() - ts < self.cache_duration:
-                    logger.info(f"[CACHE HIT] {key[:8]} len={len(translation)}")
-                    return translation
-                else:
-                    del self.cache[key]
-                    logger.info(f"[CACHE EXPIRED] {key[:8]}")
-            logger.debug(f"[CACHE MISS] {key[:8]}")
-        return None
-
-    def set(self, text: str, source_lang: str, target_lang: str, translation: str):
-        with self.lock:
-            key = self._generate_key(text, source_lang, target_lang)
-            self.cache[key] = (translation, datetime.utcnow())
-            logger.info(f"[CACHE SET] {key[:8]} len={len(translation)}")
-
-# ----------------------- Smart Chunker -----------------------
-class TextChunker:
-    """Smart splitting: paragraphs -> sentences -> commas fallback."""
-
-    @staticmethod
-    def split_text_smart(text: str, max_chunk_size: int = MAX_CHUNK_SIZE) -> List[str]:
-        text = text.strip()
-        if not text:
-            return []
-        if len(text) <= max_chunk_size:
-            return [text]
-
-        # First split by paragraphs to preserve structure
-        paragraphs = [p.strip() for p in re.split(r'\n{2,}', text) if p.strip()]
-        chunks: List[str] = []
-        current = ""
-
-        for p in paragraphs:
-            if len(p) <= max_chunk_size:
-                if not current:
-                    current = p
-                else:
-                    if len(current) + 2 + len(p) <= max_chunk_size:
-                        current += "\n\n" + p
-                    else:
-                        chunks.append(current.strip())
-                        current = p
-            else:
-                # paragraph too large -> split to sentences
-                if current:
-                    chunks.append(current.strip())
-                    current = ""
-                parts = TextChunker._split_paragraph(p, max_chunk_size)
-                chunks.extend(parts)
-
-        if current:
-            chunks.append(current.strip())
-
-        # Safety: merge very small chunks
-        merged: List[str] = []
-        for c in chunks:
-            if not merged:
-                merged.append(c)
-            else:
-                if len(merged[-1]) + 1 + len(c) <= max_chunk_size:
-                    merged[-1] = merged[-1] + "\n\n" + c
-                else:
-                    merged.append(c)
-
-        logger.info(f"[CHUNKER] split into {len(merged)} chunks (avg {sum(len(x) for x in merged)/len(merged):.1f} chars)")
-        return merged
-
-    @staticmethod
-    def _split_paragraph(paragraph: str, max_chunk_size: int) -> List[str]:
-        sentences = re.split(r'(?<=[.!?])\s+', paragraph)
-        chunks: List[str] = []
-        current = ""
-        for s in sentences:
-            s = s.strip()
-            if not s:
-                continue
-            if len(s) > max_chunk_size:
-                # fallback: split by commas
-                parts = TextChunker._split_by_comma(s, max_chunk_size)
-                if current:
-                    chunks.append(current.strip()); current = ""
-                chunks.extend(parts)
-            else:
-                if not current:
-                    current = s
-                elif len(current) + 1 + len(s) <= max_chunk_size:
-                    current += " " + s
-                else:
-                    chunks.append(current.strip())
-                    current = s
-        if current:
-            chunks.append(current.strip())
-        return chunks
-
-    @staticmethod
-    def _split_by_comma(sentence: str, max_chunk_size: int) -> List[str]:
-        parts = [p.strip() for p in sentence.split(',') if p.strip()]
-        chunks: List[str] = []
-        current = ""
-        for p in parts:
-            if len(p) > max_chunk_size:
-                # hard cut
-                i = 0
-                while i < len(p):
-                    slice_ = p[i:i+max_chunk_size].strip()
-                    if slice_:
-                        chunks.append(slice_)
-                    i += max_chunk_size
-            else:
-                if not current:
-                    current = p
-                elif len(current) + 2 + len(p) <= max_chunk_size:
-                    current += ", " + p
-                else:
-                    chunks.append(current.strip())
-                    current = p
-        if current:
-            chunks.append(current.strip())
-        return chunks
-
-# ----------------------- Translator Core -----------------------
-class MultilingualTranslator:
-    def __init__(self, cache_minutes: int = CACHE_MINUTES, max_workers: int = MAX_WORKERS):
-        self.device = "cpu"
-        self.model_name = HF_MODEL
-        self.tokenizer = None
-        self.model = None
-        self.generation_lock = threading.Lock()  # ensure model.generate serialized
-        self.executor = ThreadPoolExecutor(max_workers=max_workers)
-        self.background_tasks: Dict[str, asyncio.Task] = {}
-        self.cache = TranslationCache(cache_minutes)
-        self.current_translation: Dict[str, Dict[str, Any]] = {}
-        self.translation_lock = threading.Lock()
-        self.max_chunk_size = MAX_CHUNK_SIZE
-
-        if TRANSFORMERS_AVAILABLE:
-            try:
-                # prefer GPU if available
-                import torch as _torch
-                self.device = "cuda" if _torch.cuda.is_available() else "cpu"
-                logger.info(f"[MODEL] Loading {self.model_name} on {self.device} (this may take time)...")
-                self.tokenizer = AutoTokenizer.from_pretrained(self.model_name, use_fast=False)
-                self.model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name)
-                if self.device == "cuda":
-                    self.model.to("cuda")
-                logger.info("[MODEL] Model loaded successfully.")
-            except Exception as e:
-                logger.exception(f"[MODEL] Failed to load model '{self.model_name}': {e}")
-                self.model = None
-                self.tokenizer = None
-        else:
-            logger.warning("[MODEL] transformers not available — running in mock mode (no local model).")
-
-    # internal chunk translation executed in threadpool (but generation uses generation_lock)
-    def _translate_chunk_sync(self, text: str, src_code: str, tgt_code: str, chunk_index: int = 0, total_chunks: int = 1) -> str:
-        """Synchronous chunk translation (called in executor)."""
-        if not text:
-            return ""
-        if self.model is None or self.tokenizer is None:
-            # mock: prefix target language code if no model
-            logger.warning("[TRANSLATE] No model available, returning mock translation.")
-            return f"[{tgt_code}] {text}"
+# Initialize translator
+translator = MultilingualTranslator(60)
 
-        try:
-            # set tokenizer language if model supports
-            with self.generation_lock:
-                # some tokenizers use .src_lang (M2M100)
-                try:
-                    if hasattr(self.tokenizer, "src_lang"):
-                        self.tokenizer.src_lang = src_code
-                except Exception:
-                    pass
-
-                inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
-                if hasattr(inputs, "to"):
-                    # pyright typing
-                    pass
-                # Move tensors to device if cuda
-                import torch as _torch
-                if self.device == "cuda":
-                    for k, v in inputs.items():
-                        if isinstance(v, _torch.Tensor):
-                            inputs[k] = v.to("cuda")
-
-                # determine forced_bos_token_id if available
-                forced_bos = None
-                try:
-                    if hasattr(self.tokenizer, "get_lang_id"):
-                        forced_bos = self.tokenizer.get_lang_id(tgt_code)
-                except Exception:
-                    forced_bos = None
-
-                gen_kwargs = dict(
-                    **inputs,
-                    max_length=1024,
-                    num_beams=4,
-                    early_stopping=True
-                )
-                if forced_bos is not None:
-                    gen_kwargs["forced_bos_token_id"] = forced_bos
-
-                t0 = time.time()
-                outputs = self.model.generate(**gen_kwargs)
-                gen_time = time.time() - t0
-
-                # move to cpu if needed for decode
-                decoded = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0].strip()
-                logger.info(f"[GEN] chunk {chunk_index+1}/{total_chunks} generated in {gen_time:.2f}s len={len(decoded)}")
-                return decoded
-        except Exception as e:
-            logger.exception(f"[TRANSLATE] Error generating chunk: {e}")
-            return f"[Translation Error: {str(e)}]"
-
-    async def translate_chunk_async(self, text: str, src_code: str, tgt_code: str, chunk_index: int = 0, total_chunks: int = 1) -> str:
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(self.executor, self._translate_chunk_sync, text, src_code, tgt_code, chunk_index, total_chunks)
-
-    async def translate_text_async(self, text: str, src_code: str, tgt_code: str, session_id: Optional[str] = None) -> Tuple[str, float, int]:
-        """Full translation (async wrapper). Returns (translation, processing_time, chunks_count)"""
-        start_time = time.time()
-        if not session_id:
-            session_id = generate_session_id("sess")
-
-        # check cache full text
-        cached_full = self.cache.get(text, src_code, tgt_code)
-        if cached_full:
-            return cached_full, time.time() - start_time, 1
-
-        # short text
-        if len(text) <= self.max_chunk_size:
-            # update progress
-            with self.translation_lock:
-                self.current_translation[session_id] = {
-                    "total_chunks": 1,
-                    "completed_chunks": 0,
-                    "start_time": start_time,
-                    "source_lang": src_code,
-                    "target_lang": tgt_code
-                }
-            chunk_result = await self.translate_chunk_async(text, src_code, tgt_code, 0, 1)
-            self.cache.set(text, src_code, tgt_code, chunk_result)
-            elapsed = time.time() - start_time
-            with self.translation_lock:
-                self.current_translation.pop(session_id, None)
-            return chunk_result, elapsed, 1
-
-        # long text -> chunking
-        chunks = TextChunker.split_text_smart(text, self.max_chunk_size)
-        total = len(chunks)
-        translated_chunks: List[str] = []
-
-        with self.translation_lock:
-            self.current_translation[session_id] = {
-                "total_chunks": total,
-                "completed_chunks": 0,
-                "start_time": start_time,
-                "source_lang": src_code,
-                "target_lang": tgt_code
-            }
-
-        for i, chunk in enumerate(chunks):
-            # check cached per-chunk
-            c_cached = self.cache.get(chunk, src_code, tgt_code)
-            if c_cached:
-                translated_chunks.append(c_cached)
-                with self.translation_lock:
-                    self.current_translation[session_id]["completed_chunks"] = i + 1
-                logger.debug(f"[SESSION {session_id}] chunk {i+1}/{total} from cache")
-                continue
-
-            # translate chunk
-            chunk_translation = await self.translate_chunk_async(chunk, src_code, tgt_code, i, total)
-            translated_chunks.append(chunk_translation)
-            self.cache.set(chunk, src_code, tgt_code, chunk_translation)
-            with self.translation_lock:
-                self.current_translation[session_id]["completed_chunks"] = i + 1
-
-            # short pause to yield CPU
-            await asyncio.sleep(0.01)
-
-        # combine
-        final = self._combine_translations(translated_chunks, text)
-
-        # set full-text cache
-        self.cache.set(text, src_code, tgt_code, final)
-
-        elapsed = time.time() - start_time
-        with self.translation_lock:
-            self.current_translation.pop(session_id, None)
-
-        return final, elapsed, total
-
-    def submit_background(self, text: str, src_code: str, tgt_code: str, session_id: Optional[str] = None) -> str:
-        """Schedule background translation and return session_id immediately"""
-        if not session_id:
-            session_id = generate_session_id("bg")
-        loop = asyncio.get_event_loop()
-        task = loop.create_task(self._bg_task_wrapper(text, src_code, tgt_code, session_id))
-        self.background_tasks[session_id] = task
-        logger.info(f"[BG] Scheduled background task {session_id}")
-        return session_id
-
-    async def _bg_task_wrapper(self, text: str, src_code: str, tgt_code: str, session_id: str):
-        """Wrapper executed in background to run translate_text_async and keep result accessible"""
-        try:
-            result, elapsed, chunks = await self.translate_text_async(text, src_code, tgt_code, session_id)
-            # store result for retrieval
-            with self.translation_lock:
-                # we can store result in background_tasks as result property or a separate dict
-                # here, we'll attach attributes to task for simplicity
-                task = self.background_tasks.get(session_id)
-                if task is not None:
-                    # monkeypatch result
-                    setattr(task, "result_data", {
-                        "translation": result,
-                        "processing_time": elapsed,
-                        "chunks": chunks,
-                        "character_count": len(text),
-                        "status": "completed"
-                    })
-            logger.info(f"[BG] Completed background {session_id} len={len(result)}")
-        except Exception as e:
-            logger.exception(f"[BG] Error in background task {session_id}: {e}")
-            task = self.background_tasks.get(session_id)
-            if task is not None:
-                setattr(task, "result_data", {
-                    "translation": None,
-                    "processing_time": 0.0,
-                    "chunks": 0,
-                    "character_count": len(text),
-                    "status": "failed",
-                    "error": str(e)
-                })
-
-    def get_background_result(self, session_id: str) -> Optional[Dict]:
-        task = self.background_tasks.get(session_id)
-        if not task:
-            return None
-        if task.done():
-            # if result_data present, return it
-            res = getattr(task, "result_data", None)
-            # cleanup
-            try:
-                del self.background_tasks[session_id]
-            except KeyError:
-                pass
-            return res
-        else:
-            return {
-                "status": "processing",
-                "progress": self.get_translation_progress(session_id)
-            }
-
-    def get_translation_progress(self, session_id: str) -> Optional[Dict]:
-        with self.translation_lock:
-            if session_id not in self.current_translation:
-                return None
-            p = self.current_translation[session_id].copy()
-        elapsed = time.time() - p['start_time']
-        completed = p.get('completed_chunks', 0)
-        total = p.get('total_chunks', 1)
-        estimated_remaining = None
-        if completed > 0:
-            avg = elapsed / completed
-            estimated_remaining = avg * (total - completed)
-        return {
-            "total_chunks": total,
-            "completed_chunks": completed,
-            "elapsed_time": elapsed,
-            "estimated_remaining": estimated_remaining,
-            "progress_percentage": (completed / total) * 100 if total else 0
-        }
-
-    def _combine_translations(self, translated_chunks: List[str], original_text: str) -> str:
-        # simple join preserving paragraph breaks if existed
-        if not translated_chunks:
-            return ""
-        # if original had paragraphs
-        if "\n\n" in original_text:
-            sep = "\n\n"
-        else:
-            sep = " "
-        combined = sep.join([c.strip() for c in translated_chunks if c and c.strip()])
-        # normalize whitespace
-        combined = re.sub(r'\s+', ' ', combined).strip()
-        return combined
-
-# ----------------------- Translator Initialization -----------------------
-translator = MultilingualTranslator(cache_minutes=CACHE_MINUTES, max_workers=MAX_WORKERS)
-
-# ----------------------- FastAPI App -----------------------
+# Create FastAPI app
 app = FastAPI(title="Enhanced Multilingual Translation API", version="2.1.0")
+
+# Add CORS middleware
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # in production, set your WP domain(s)
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# ----------------------- Routes -----------------------
-@app.get("/")
-async def root():
-    return {
-        "message": "Enhanced Multilingual Translation API v2.1",
-        "status": "active",
-        "model": translator.model_name,
-        "device": getattr(translator, "device", "cpu"),
-        "features": ["cache", "background_tasks", "progress_tracking", "chunking"]
-    }
+# ========== NEW WORDPRESS INTEGRATION ENDPOINTS ==========
 
-@app.post("/api/translate", response_model=TranslationResponse)
-async def api_translate(request: TranslationRequest):
+@app.post("/api/check-completion")
+async def check_completion(request: Request):
     """
-    JSON endpoint for synchronous translation. Waits until translation completes.
-    (Suitable for short texts)
+    FIXED: Enhanced completion verification endpoint
     """
-    text = request.text or ""
-    if not text.strip():
-        raise HTTPException(status_code=400, detail="No text provided")
-
-    # map language names to codes if needed
-    src_code = LANGUAGE_MAP.get(request.source_lang, request.source_lang)
-    tgt_code = LANGUAGE_MAP.get(request.target_lang, request.target_lang)
+    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] 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),
+                    'character_count': completion_data.get('character_count', 0),
+                    'translation_length': len(completion_data.get('translation', '')),
+                    '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,
+                    'progress': translation_requests[request_id].get('progress', 0),
+                    '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"[HF Server] Error in check_completion: {str(e)}")
+        return {
+            'status': 'error',
+            'message': 'Server error occurred'
+        }
 
-    # Run translation (async)
+@app.post("/api/check-translation-status")
+async def check_translation_status(request: Request):
+    """
+    FIXED: Enhanced translation status endpoint with full translation content
+    """
     try:
-        translation, processing_time, chunks_count = await translator.translate_text_async(text, src_code, tgt_code)
-        return TranslationResponse(
-            translation=translation,
-            source_language=request.source_lang,
-            target_language=request.target_lang,
-            processing_time=float(processing_time),
-            character_count=len(text),
-            status="success",
-            chunks_processed=chunks_count,
-            estimated_time_remaining=0.0,
-            current_chunk=chunks_count,
-            total_chunks=chunks_count,
-            session_id=None
-        )
+        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 full data")
+                
+                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_display', result.get('source_lang', '')),
+                    'target_lang': result.get('target_lang_display', result.get('target_lang', '')),
+                    'chunks_processed': result.get('chunks_processed', 1),
+                    'translation_length': len(result.get('translation', ''))
+                }
+            
+            # 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),
+                    'character_count': req_data.get('character_count', 0),
+                    'source_lang': req_data.get('source_lang_display', req_data.get('source_lang', '')),
+                    'target_lang': req_data.get('target_lang_display', req_data.get('target_lang', ''))
+                }
+            
+            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.exception("[API] translate error")
-        raise HTTPException(status_code=500, detail=str(e))
+        logger.error(f"[HF Server] Error in check_translation_status: {str(e)}")
+        return {
+            'status': 'error',
+            'message': 'Server error occurred'
+        }
+
+# ========== UPDATED MAIN TRANSLATION ENDPOINT ==========
 
 @app.post("/api/translate/form")
 async def api_translate_form(request: Request):
     """
-    Compatibility endpoint for form-data (used by WP plugin's call).
-    Accepts either form-encoded or JSON payload.
-    Behavior:
-      - If short text -> translate immediately and return translation
-      - If long text -> check cache; if cached return result; else schedule background and return session info
+    FIXED: Enhanced translation endpoint with better heavy text handling
     """
     try:
-        form = await request.form()
-        # form() returns a starlette.datastructures.FormData object; fallback if empty
-        data = dict(form) if form else {}
-        # prefer form fields
-        text = data.get("text") or (await request.json()).get("text") if request.headers.get("content-type", "").startswith("application/json") else None
-        source_lang = data.get("source_lang") or (await request.json()).get("source_lang") if text is None else data.get("source_lang")
-        target_lang = data.get("target_lang") or (await request.json()).get("target_lang") if text is None else data.get("target_lang")
-        api_key = data.get("api_key") or None
-    except Exception:
-        # fallback: try json directly
+        form_data = await request.form()
+        text = form_data.get("text", "")
+        source_lang = form_data.get("source_lang", "")
+        target_lang = form_data.get("target_lang", "")
+        api_key = form_data.get("api_key", None)
+    except:
         try:
-            payload = await request.json()
-            text = payload.get("text", "")
-            source_lang = payload.get("source_lang", "")
-            target_lang = payload.get("target_lang", "")
-            api_key = payload.get("api_key", None)
-        except Exception:
-            raise HTTPException(status_code=400, detail="Invalid request format")
-
-    text = text or ""
-    source_lang = source_lang or ""
-    target_lang = target_lang or ""
-
-    logger.info(f"[FORM API] Request: {len(text)} chars | {source_lang} -> {target_lang}")
-
+            json_data = await request.json()
+            text = json_data.get("text", "")
+            source_lang = json_data.get("source_lang", "")
+            target_lang = json_data.get("target_lang", "")
+            api_key = json_data.get("api_key", None)
+        except:
+            return {"status": "error", "message": "Invalid request format"}
+    
     if not text.strip():
-        return {"status": "error", "message": "No text provided"}
-
-    src_code = LANGUAGE_MAP.get(source_lang, source_lang)
-    tgt_code = LANGUAGE_MAP.get(target_lang, target_lang)
-
-    # Generate session id
-    session_id = generate_session_id("req")
-
-    # If long text -> background
-    if len(text) > translator.max_chunk_size:
-        # Check full-text cache first
-        cached_full = translator.cache.get(text, src_code, tgt_code)
-        if cached_full:
-            logger.info(f"[FORM API] returning cached full result for session {session_id}")
+        logger.error("[FORM API] 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)
+    
+    if not source_code or not target_code:
+        logger.error(f"[FORM API] Invalid language codes: {source_lang} -> {target_lang}")
+        return {"status": "error", "message": "Invalid language codes"}
+    
+    char_count = len(text)
+    # FIXED: Correct heavy text threshold detection
+    is_heavy_text = char_count > 1000  # Same as WordPress threshold
+    
+    logger.info(f"[FORM API] Translation request: {char_count} chars, {source_lang} → {target_lang}, Heavy: {is_heavy_text}")
+    
+    # FIXED: Always use background processing for heavy texts
+    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 request: {request_id}")
             return {
-                "translation": cached_full,
+                "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,
+                "request_id": request_id,
                 "cached": True
             }
-
-        # schedule background translation
-        # ensure we schedule within event loop
-        loop = asyncio.get_event_loop()
-        task = loop.create_task(translator._bg_task_wrapper(text, src_code, tgt_code, session_id))
-        translator.background_tasks[session_id] = task
-        logger.info(f"[FORM API] background scheduled session {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,
+                'source_lang_display': source_lang,
+                'target_lang_display': target_lang
+            }
+        
+        # Start background processing
+        thread = threading.Thread(
+            target=process_heavy_translation_background,
+            args=(request_id, text, source_code, target_code)
+        )
+        thread.daemon = True
+        thread.start()
+        
+        logger.info(f"[FORM API] Started background processing for heavy text - request: {request_id}")
+        
+        # FIXED: Return proper background response for WordPress
         return {
-            "session_id": session_id,
-            "request_id": session_id,
-            "status": "processing",
-            "message": "Translation started in background. Use /api/status/{session_id} or /api/progress/{session_id} to check.",
-            "character_count": len(text),
-            "is_background": True,
-            "is_heavy_text": True
+            'is_background': True,
+            'session_id': request_id,
+            'request_id': request_id,
+            'server_request_id': request_id,  # Added for compatibility
+            'status': 'processing',
+            'is_heavy_text': True,
+            'message': f'Heavy text ({char_count} characters) is being processed in background. Translation will appear automatically.',
+            'character_count': char_count,
+            'source_lang': source_lang,
+            'target_lang': target_lang
         }
+    
     else:
-        # short text - translate immediately
+        # Process short text immediately
         try:
-            translation, processing_time, chunks_count = await translator.translate_text_async(text, src_code, tgt_code, session_id)
-            # validate
-            if not translation or (isinstance(translation, str) and translation.lower().startswith("translation error")):
-                logger.error("[FORM API] Invalid translation result")
-                return {"status": "error", "message": "Translation failed - empty or invalid result", "session_id": 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"
+                }
+            
+            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,
-                "cached": False
+                'status': 'success',
+                'translation': translation,
+                'processing_time': processing_time,
+                'character_count': char_count,
+                'source_lang': source_lang,
+                'target_lang': target_lang,
+                'is_heavy_text': False,
+                'chunks_processed': chunks_count
             }
+            
         except Exception as e:
-            logger.exception("[FORM API] translation error")
-            return {"status": "error", "message": f"Translation error: {str(e)}"}
+            logger.error(f"[FORM API] Translation error: {str(e)}")
+            return {"status": "error", "message": f"Translation failed: {str(e)}"}
 
-@app.get("/api/status/{session_id}")
-async def get_session_status(session_id: str):
-    """Return completed result if available, or processing state."""
-    # check background tasks dict first
-    bg = translator.background_tasks.get(session_id)
-    if bg:
-        if bg.done():
-            res = getattr(bg, "result_data", None)
-            if res:
-                return {
-                    "status": "completed",
-                    "translation": res.get("translation"),
-                    "processing_time": res.get("processing_time"),
-                    "chunks_processed": res.get("chunks"),
-                    "character_count": res.get("character_count")
-                }
-            else:
-                return {"status": "completed", "message": "Completed but no data"}
-        else:
-            progress = translator.get_translation_progress(session_id)
-            return {"status": "processing", "progress": progress}
+# ========== EXISTING ENDPOINTS (UPDATED) ==========
 
-    # else check current_translation (in-progress immediate)
-    prog = translator.get_translation_progress(session_id)
-    if prog:
-        return {"status": "processing", "progress": prog}
-    return {"status": "not_found", "message": "Session not found or already cleaned up"}
+@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):
-    p = translator.get_translation_progress(session_id)
-    if p is None:
+    """Get translation progress for a session"""
+    progress = translator.get_translation_progress(session_id)
+    if progress is None:
         raise HTTPException(status_code=404, detail="Session not found or completed")
-    return {"status": "success", "progress": p}
-
-@app.get("/api/result/{session_id}")
-async def get_result(session_id: str):
-    # check background
-    bg = translator.background_tasks.get(session_id)
-    if bg and bg.done():
-        res = getattr(bg, "result_data", None)
-        if res:
-            return {
-                "status": "success",
-                "translation": res.get("translation"),
-                "processing_time": res.get("processing_time"),
-                "character_count": res.get("character_count"),
-                "chunks_processed": res.get("chunks"),
-                "session_id": session_id
-            }
-        else:
-            return {"status": "error", "message": "Completed but no result data"}
-
-    # if still processing
-    prog = translator.get_translation_progress(session_id)
-    if prog:
-        return {"status": "processing", "progress": prog}
-
-    # maybe not found
-    raise HTTPException(status_code=404, detail="Session not found")
+    
+    return {
+        "status": "success",
+        "progress": progress
+    }
 
 @app.get("/api/languages")
 async def get_languages():
-    return {"languages": list(LANGUAGE_MAP.keys()), "language_codes": LANGUAGE_MAP, "status": "success"}
+    """Get supported languages"""
+    return {
+        "languages": list(LANGUAGE_MAP.keys()),
+        "language_codes": LANGUAGE_MAP,
+        "status": "success"
+    }
 
 @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": getattr(translator, "device", "cpu"),
-        "model": getattr(translator, "model_name", None),
+        "device": str(translator.device),
+        "model": translator.model_name,
         "cache_size": len(translator.cache.cache),
         "max_chunk_size": translator.max_chunk_size,
         "active_translations": len(translator.current_translation),
-        "background_tasks": len(translator.background_tasks),
+        "active_requests": active_requests,
+        "completed_cache": completed_cache,
         "version": "2.1.0"
     }
 
+@app.get("/api/status/{session_id}")
+async def get_session_status(session_id: str):
+    """Get translation status - non-blocking"""
+    
+    # Check if task is in background tasks
+    if session_id in translator.background_tasks:
+        task = translator.background_tasks[session_id]
+        
+        if task.done():
+            try:
+                translation, processing_time, chunks_count = await task
+                # Clean up completed task
+                del translator.background_tasks[session_id]
+                
+                return {
+                    "status": "completed",
+                    "translation": translation,
+                    "processing_time": processing_time,
+                    "chunks_processed": chunks_count,
+                    "message": "Translation completed successfully"
+                }
+            except Exception as e:
+                del translator.background_tasks[session_id]
+                return {
+                    "status": "failed",
+                    "message": f"Translation failed: {str(e)}"
+                }
+        else:
+            # Task still running - get progress
+            progress = translator.get_translation_progress(session_id)
+            
+            if progress:
+                return {
+                    "status": "processing",
+                    "progress": progress,
+                    "message": f"Processing chunk {progress['completed_chunks']}/{progress['total_chunks']}",
+                    "estimated_remaining": progress.get('estimated_remaining', 0)
+                }
+            else:
+                return {
+                    "status": "processing",
+                    "message": "Translation in progress...",
+                    "progress": None
+                }
+    
+    # Check current active translations
+    progress = translator.get_translation_progress(session_id)
+    if progress:
+        return {
+            "status": "processing",
+            "progress": progress,
+            "message": f"Processing chunk {progress['completed_chunks']}/{progress['total_chunks']}",
+            "estimated_remaining": progress.get('estimated_remaining', 0)
+        }
+    
+    return {
+        "status": "not_found",
+        "message": "Session not found or completed"
+    }
+
 @app.get("/api/server-status")
 async def get_server_status():
+    """
+    FIXED: Enhanced server status with better information
+    """
     active_sessions = []
+    
+    with translation_requests_lock:
+        background_tasks_count = len(translation_requests)
+        completed_count = len(completed_translations)
+    
     with translator.translation_lock:
-        for sid, progress in translator.current_translation.items():
-            elapsed = time.time() - progress['start_time']
-            completed = progress.get('completed_chunks', 0)
-            total = progress.get('total_chunks', 1)
-            percent = (completed / total) * 100 if total else 0
+        for session_id, progress in translator.current_translation.items():
+            elapsed_time = time.time() - progress['start_time']
+            if progress['completed_chunks'] > 0:
+                avg_time_per_chunk = elapsed_time / progress['completed_chunks']
+                remaining_chunks = progress['total_chunks'] - progress['completed_chunks']
+                estimated_remaining = avg_time_per_chunk * remaining_chunks
+            else:
+                estimated_remaining = None
+            
             active_sessions.append({
-                "session_id": sid,
-                "source_lang": progress.get('source_lang'),
-                "target_lang": progress.get('target_lang'),
-                "total_chunks": total,
-                "completed_chunks": completed,
-                "progress_percentage": percent,
-                "elapsed_time": elapsed
+                'session_id': session_id,
+                'source_lang': progress['source_lang'],
+                'target_lang': progress['target_lang'],
+                'total_chunks': progress['total_chunks'],
+                'completed_chunks': progress['completed_chunks'],
+                'progress_percentage': (progress['completed_chunks'] / progress['total_chunks']) * 100,
+                'elapsed_time': elapsed_time,
+                'estimated_remaining': estimated_remaining
             })
-    bg_count = len(translator.background_tasks)
-    return {
-        "has_active_translation": bool(active_sessions) or bg_count > 0,
-        "active_sessions": active_sessions,
-        "background_tasks": bg_count,
-        "message": f"{len(active_sessions)} active, {bg_count} in background"
-    }
+    
+    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']}"
+        else:
+            message = f"{background_tasks_count} translation(s) in background queue"
+            
+        return {
+            "has_active_translation": True,
+            "status": "processing",
+            "message": message,
+            "active_sessions": len(active_sessions),
+            "background_tasks": background_tasks_count,
+            "total_active": total_active,
+            "completed_cache": completed_count,
+            "active_session_details": active_sessions[:3] if active_sessions else []  # Return first 3 for details
+        }
+    else:
+        return {
+            "has_active_translation": False,
+            "status": "idle",
+            "message": "Server is ready for new translations",
+            "active_sessions": 0,
+            "background_tasks": 0,
+            "completed_cache": completed_count
+        }
+
+# ========== CLEANUP AND MAINTENANCE FUNCTIONS ==========
+
+def cleanup_old_requests():
+    """
+    FIXED: Enhanced cleanup with better time handling
+    """
+    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)
+
+# Schedule periodic cleanup (runs every hour)
+def periodic_cleanup():
+    """Run cleanup every hour"""
+    while True:
+        time.sleep(3600)  # 1 hour
+        try:
+            cleanup_old_requests()
+        except Exception as 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 ==========
 
-# ----------------------- Run -----------------------
 if __name__ == "__main__":
-    # uvicorn.run(app, host="0.0.0.0", port=7860)
-    logger.info(f"Starting server on {SERVER_HOST}:{SERVER_PORT} (model={translator.model_name})")
-    uvicorn.run("app:app", host=SERVER_HOST, port=SERVER_PORT, log_level="info", reload=False)
+    logger.info("[HF Server] Starting Enhanced Multilingual Translation API with WordPress Integration")
+    uvicorn.run(app, host="0.0.0.0", port=7860)