app.py

import os
import re
import torch
import logging
import gc
import sys
import numpy as np
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from typing import Dict, List, Optional
from transformers import (
    AutoTokenizer, 
    AutoModelForSequenceClassification,
    AutoModelForCausalLM,
    pipeline
)
from tokenizers.normalizers import Sequence, Replace, Strip
from tokenizers import Regex
import math
from collections import Counter

# =====================================================
# 🔧 تكوين البيئة والإعدادات
# =====================================================
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# إعدادات الذاكرة والكاش
CACHE_DIR = "/tmp/huggingface_cache"
os.makedirs(CACHE_DIR, exist_ok=True)

# تكوين متغيرات البيئة لـ Hugging Face
os.environ.update({
    "HF_HOME": CACHE_DIR,
    "TRANSFORMERS_CACHE": CACHE_DIR,
    "HF_DATASETS_CACHE": CACHE_DIR,
    "HUGGINGFACE_HUB_CACHE": CACHE_DIR,
    "TORCH_HOME": CACHE_DIR,
    "TOKENIZERS_PARALLELISM": "false",
    "TRANSFORMERS_OFFLINE": "0",
})

# إعدادات PyTorch للذاكرة
if torch.cuda.is_available():
    os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:128'
    torch.backends.cudnn.benchmark = True

# =====================================================
# 🚀 تحديد الجهاز (GPU أو CPU)
# =====================================================
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
logger.info(f"🖥️ Using device: {device}")
if torch.cuda.is_available():
    logger.info(f"🎮 CUDA Device: {torch.cuda.get_device_name(0)}")
    logger.info(f"💾 CUDA Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")

# =====================================================
# 📊 خريطة الموديلات
# =====================================================
label_mapping = {
    0: '13B', 1: '30B', 2: '65B', 3: '7B', 4: 'GLM130B', 5: 'bloom_7b',
    6: 'bloomz', 7: 'cohere', 8: 'davinci', 9: 'dolly', 10: 'dolly-v2-12b',
    11: 'flan_t5_base', 12: 'flan_t5_large', 13: 'flan_t5_small',
    14: 'flan_t5_xl', 15: 'flan_t5_xxl', 16: 'gemma-7b-it', 17: 'gemma2-9b-it',
    18: 'gpt-3.5-turbo', 19: 'gpt-35', 20: 'gpt4', 21: 'gpt4o',
    22: 'gpt_j', 23: 'gpt_neox', 24: 'human', 25: 'llama3-70b', 26: 'llama3-8b',
    27: 'mixtral-8x7b', 28: 'opt_1.3b', 29: 'opt_125m', 30: 'opt_13b',
    31: 'opt_2.7b', 32: 'opt_30b', 33: 'opt_350m', 34: 'opt_6.7b',
    35: 'opt_iml_30b', 36: 'opt_iml_max_1.3b', 37: 't0_11b', 38: 't0_3b',
    39: 'text-davinci-002', 40: 'text-davinci-003'
}

# =====================================================
# 📈 حسابات Perplexity و Burstiness
# =====================================================
class TextMetrics:
    """حساب المقاييس الإحصائية للنص"""
    
    @staticmethod
    def calculate_perplexity(text: str, model=None, tokenizer=None):
        """
        حساب Perplexity - قياس مدى "تفاجؤ" الموديل بالنص
        نصوص AI عادة لها perplexity أقل (أكثر قابلية للتنبؤ)
        """
        try:
            if model is None or tokenizer is None:
                # حساب تقريبي بناءً على تكرار الكلمات
                words = text.lower().split()
                word_freq = Counter(words)
                total_words = len(words)
                
                # حساب entropy
                entropy = 0
                for count in word_freq.values():
                    probability = count / total_words
                    if probability > 0:
                        entropy -= probability * math.log2(probability)
                
                # تقريب perplexity
                perplexity = 2 ** entropy
                return min(perplexity, 1000)  # Cap at 1000
            else:
                # حساب حقيقي باستخدام موديل
                inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
                with torch.no_grad():
                    outputs = model(**inputs, labels=inputs["input_ids"])
                    loss = outputs.loss
                    perplexity = torch.exp(loss).item()
                return min(perplexity, 1000)
        except Exception as e:
            logger.warning(f"Error calculating perplexity: {e}")
            return 50.0  # Default value
    
    @staticmethod
    def calculate_burstiness(text: str):
        """
        حساب Burstiness - قياس التنوع في طول الجمل
        البشر عندهم burstiness أعلى (جمل متنوعة الطول)
        AI عادة أكثر اتساقاً
        """
        try:
            # تقسيم النص لجمل
            sentences = re.split(r'[.!?]+', text)
            sentences = [s.strip() for s in sentences if s.strip()]
            
            if len(sentences) < 2:
                return 0.0
            
            # حساب طول كل جملة
            sentence_lengths = [len(s.split()) for s in sentences]
            
            # حساب الانحراف المعياري والمتوسط
            mean_length = np.mean(sentence_lengths)
            std_length = np.std(sentence_lengths)
            
            # Burstiness = الانحراف المعياري / المتوسط
            if mean_length > 0:
                burstiness = std_length / mean_length
            else:
                burstiness = 0.0
            
            return round(burstiness, 4)
        except Exception as e:
            logger.warning(f"Error calculating burstiness: {e}")
            return 0.5
    
    @staticmethod
    def calculate_vocabulary_diversity(text: str):
        """
        حساب تنوع المفردات
        البشر يستخدمون كلمات أكثر تنوعاً
        """
        words = text.lower().split()
        unique_words = set(words)
        if len(words) > 0:
            diversity = len(unique_words) / len(words)
        else:
            diversity = 0
        return round(diversity, 4)
    
    @staticmethod
    def detect_ai_patterns(text: str):
        """
        كشف الأنماط الشائعة في نصوص AI
        """
        ai_patterns = [
            r"it['\s]+s important to note",
            r"in conclusion",
            r"furthermore",
            r"comprehensive understanding",
            r"it is worth noting",
            r"however, it should be noted",
            r"on the other hand",
            r"in summary",
            r"to begin with",
            r"first and foremost"
        ]
        
        pattern_count = 0
        for pattern in ai_patterns:
            if re.search(pattern, text.lower()):
                pattern_count += 1
        
        return pattern_count
    
    @staticmethod
    def detect_human_patterns(text: str):
        """
        كشف الأنماط الشائعة في الكتابة البشرية
        """
        human_patterns = [
            r"kinda|sorta|gonna|wanna|gotta",
            r"tbh|idk|lol|omg|btw",
            r"!{2,}|\?{2,}|\.{3,}",
            r"i think|i feel|i believe",
            r"like,|you know,|i mean,",
            r"anyway|anyhow|whatever"
        ]
        
        pattern_count = 0
        for pattern in human_patterns:
            if re.search(pattern, text.lower()):
                pattern_count += 1
        
        return pattern_count

# =====================================================
# 🤖 Model Manager - إدارة الموديلات المحسنة
# =====================================================
class EnhancedModelManager:
    def __init__(self):
        self.modernbert_tokenizer = None
        self.modernbert_models = []
        self.additional_models = {}
        self.additional_tokenizers = {}
        self.models_loaded = False
        self.metrics = TextMetrics()
        
        # ModernBERT URLs
        self.modernbert_urls = [
            "https://huggingface.co/mihalykiss/modernbert_2/resolve/main/Model_groups_3class_seed12",
            "https://huggingface.co/mihalykiss/modernbert_2/resolve/main/Model_groups_3class_seed22"
        ]
        
        # Additional models to try
        self.additional_model_configs = [
            {
                "name": "chatgpt-detector-roberta",
                "model_id": "Hello-SimpleAI/chatgpt-detector-roberta",
                "type": "classification"
            },
            {
                "name": "openai-detector",
                "model_id": "roberta-base-openai-detector",
                "type": "classification"
            },
            {
                "name": "ai-content-detector",
                "model_id": "PirateXX/AI-Content-Detector",
                "type": "classification"
            }
        ]
    
    def load_modernbert_tokenizer(self):
        """تحميل ModernBERT tokenizer"""
        try:
            logger.info("📝 Loading ModernBERT tokenizer...")
            self.modernbert_tokenizer = AutoTokenizer.from_pretrained(
                "answerdotai/ModernBERT-base",
                cache_dir=CACHE_DIR,
                use_fast=True,
                trust_remote_code=False
            )
            
            # إعداد معالج النصوص
            try:
                newline_to_space = Replace(Regex(r'\s*\n\s*'), " ")
                join_hyphen_break = Replace(Regex(r'(\w+)[--]\s*\n\s*(\w+)'), r"\1\2")
                self.modernbert_tokenizer.backend_tokenizer.normalizer = Sequence([
                    self.modernbert_tokenizer.backend_tokenizer.normalizer,
                    join_hyphen_break,
                    newline_to_space,
                    Strip()
                ])
            except Exception as e:
                logger.warning(f"⚠️ Could not set custom normalizer: {e}")
            
            logger.info("✅ ModernBERT tokenizer loaded")
            return True
        except Exception as e:
            logger.error(f"❌ Failed to load tokenizer: {e}")
            return False
    
    def load_modernbert_model(self, model_url=None, model_path=None, model_name="ModernBERT"):
        """تحميل موديل ModernBERT واحد"""
        try:
            logger.info(f"🤖 Loading {model_name}...")
            
            base_model = AutoModelForSequenceClassification.from_pretrained(
                "answerdotai/ModernBERT-base",
                num_labels=41,
                cache_dir=CACHE_DIR,
                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
                low_cpu_mem_usage=True,
                trust_remote_code=False
            )
            
            if model_path and os.path.exists(model_path):
                logger.info(f"📁 Loading from local file: {model_path}")
                state_dict = torch.load(model_path, map_location=device, weights_only=True)
                base_model.load_state_dict(state_dict, strict=False)
            elif model_url:
                logger.info(f"🌐 Downloading weights from URL...")
                try:
                    state_dict = torch.hub.load_state_dict_from_url(
                        model_url,
                        map_location=device,
                        progress=True,
                        check_hash=False,
                        file_name=f"{model_name}.pt"
                    )
                    base_model.load_state_dict(state_dict, strict=False)
                except Exception as e:
                    logger.warning(f"⚠️ Could not load weights: {e}")
                    logger.info("📊 Using model with random initialization")
            
            model = base_model.to(device)
            model.eval()
            
            if 'state_dict' in locals():
                del state_dict
            gc.collect()
            if torch.cuda.is_available():
                torch.cuda.empty_cache()
            
            logger.info(f"✅ {model_name} loaded")
            return model
            
        except Exception as e:
            logger.error(f"❌ Failed to load {model_name}: {e}")
            return None
    
    def load_additional_model(self, model_config):
        """تحميل موديلات إضافية للكشف عن AI"""
        try:
            model_name = model_config["name"]
            model_id = model_config["model_id"]
            
            logger.info(f"🔧 Loading {model_name}...")
            
            # Try loading as a pipeline first (easier)
            try:
                classifier = pipeline(
                    "text-classification",
                    model=model_id,
                    device=0 if torch.cuda.is_available() else -1,
                    model_kwargs={"cache_dir": CACHE_DIR}
                )
                self.additional_models[model_name] = classifier
                logger.info(f"✅ {model_name} loaded as pipeline")
                return True
            except:
                # Try loading manually
                tokenizer = AutoTokenizer.from_pretrained(
                    model_id,
                    cache_dir=CACHE_DIR
                )
                model = AutoModelForSequenceClassification.from_pretrained(
                    model_id,
                    cache_dir=CACHE_DIR,
                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
                ).to(device)
                model.eval()
                
                self.additional_tokenizers[model_name] = tokenizer
                self.additional_models[model_name] = model
                logger.info(f"✅ {model_name} loaded manually")
                return True
                
        except Exception as e:
            logger.warning(f"⚠️ Could not load {model_config['name']}: {e}")
            return False
    
    def load_all_models(self, max_modernbert=2, load_additional=True):
        """تحميل جميع الموديلات"""
        if self.models_loaded:
            logger.info("✨ Models already loaded")
            return True
        
        # Load ModernBERT tokenizer
        if not self.load_modernbert_tokenizer():
            return False
        
        # Load ModernBERT models
        logger.info(f"🚀 Loading up to {max_modernbert} ModernBERT models...")
        
        # Try local file first
        local_path = "modernbert.bin"
        if os.path.exists(local_path):
            model = self.load_modernbert_model(
                model_path=local_path,
                model_name="ModernBERT-Local"
            )
            if model is not None:
                self.modernbert_models.append(model)
        
        # Load from URLs
        for i, url in enumerate(self.modernbert_urls[:max_modernbert - len(self.modernbert_models)]):
            if len(self.modernbert_models) >= max_modernbert:
                break
            
            model = self.load_modernbert_model(
                model_url=url,
                model_name=f"ModernBERT-{i+1}"
            )
            if model is not None:
                self.modernbert_models.append(model)
        
        # Load additional models
        if load_additional:
            logger.info("🎯 Loading additional AI detection models...")
            for config in self.additional_model_configs:
                self.load_additional_model(config)
        
        # Check success
        total_models = len(self.modernbert_models) + len(self.additional_models)
        if total_models > 0:
            self.models_loaded = True
            logger.info(f"✅ Loaded {len(self.modernbert_models)} ModernBERT + {len(self.additional_models)} additional models")
            return True
        else:
            logger.error("❌ No models could be loaded")
            return False
    
    def classify_with_modernbert(self, text: str, model_index: int):
        """تصنيف النص باستخدام موديل ModernBERT واحد"""
        try:
            if model_index >= len(self.modernbert_models):
                return None
            
            model = self.modernbert_models[model_index]
            cleaned_text = clean_text(text)
            
            inputs = self.modernbert_tokenizer(
                cleaned_text,
                return_tensors="pt",
                truncation=True,
                max_length=512,
                padding=True
            ).to(device)
            
            with torch.no_grad():
                logits = model(**inputs).logits
                probs = torch.softmax(logits[0], dim=0)
                
                human_prob = probs[24].item()
                ai_probs = probs.clone()
                ai_probs[24] = 0
                ai_total = ai_probs.sum().item()
                
                total = human_prob + ai_total
                if total > 0:
                    human_pct = (human_prob / total) * 100
                    ai_pct = (ai_total / total) * 100
                else:
                    human_pct = ai_pct = 50
                
                ai_model_idx = torch.argmax(ai_probs).item()
                
                return {
                    "model_name": f"ModernBERT-{model_index+1}",
                    "human_score": round(human_pct, 2),
                    "ai_score": round(ai_pct, 2),
                    "predicted_model": label_mapping.get(ai_model_idx, "Unknown"),
                    "confidence": round(max(human_pct, ai_pct), 2)
                }
        except Exception as e:
            logger.error(f"Error in ModernBERT {model_index}: {e}")
            return None
    
    def classify_with_additional(self, text: str, model_name: str):
        """تصنيف النص باستخدام موديل إضافي"""
        try:
            if model_name not in self.additional_models:
                return None
            
            model = self.additional_models[model_name]
            
            # Check if it's a pipeline or model
            if hasattr(model, '__call__'):
                # It's a pipeline
                result = model(text, truncation=True, max_length=512)
                
                # Parse results based on model output format
                ai_score = 0
                human_score = 0
                
                for item in result:
                    label = item['label'].lower()
                    score = item['score'] * 100
                    
                    if 'fake' in label or 'ai' in label or 'gpt' in label:
                        ai_score = max(ai_score, score)
                    elif 'real' in label or 'human' in label:
                        human_score = max(human_score, score)
                
                # Normalize if needed
                if ai_score == 0 and human_score == 0:
                    ai_score = human_score = 50
                
                return {
                    "model_name": model_name,
                    "human_score": round(human_score, 2),
                    "ai_score": round(ai_score, 2),
                    "predicted_model": "AI" if ai_score > human_score else "Human",
                    "confidence": round(max(ai_score, human_score), 2)
                }
            else:
                # It's a model, use tokenizer
                tokenizer = self.additional_tokenizers.get(model_name)
                if tokenizer is None:
                    return None
                
                inputs = tokenizer(
                    text,
                    return_tensors="pt",
                    truncation=True,
                    max_length=512,
                    padding=True
                ).to(device)
                
                with torch.no_grad():
                    outputs = model(**inputs)
                    probs = torch.softmax(outputs.logits[0], dim=0)
                    
                    # Assuming binary classification (AI vs Human)
                    if len(probs) == 2:
                        human_score = probs[0].item() * 100
                        ai_score = probs[1].item() * 100
                    else:
                        # Handle multi-class
                        ai_score = human_score = 50
                    
                    return {
                        "model_name": model_name,
                        "human_score": round(human_score, 2),
                        "ai_score": round(ai_score, 2),
                        "predicted_model": "AI" if ai_score > human_score else "Human",
                        "confidence": round(max(ai_score, human_score), 2)
                    }
                    
        except Exception as e:
            logger.warning(f"Error in {model_name}: {e}")
            return None
    
    def comprehensive_analysis(self, text: str):
        """تحليل شامل باستخدام جميع الموديلات والمقاييس"""
        if not self.models_loaded:
            raise ValueError("No models loaded")
        
        results = {
            "individual_models": [],
            "ensemble_result": {},
            "metrics": {},
            "pattern_analysis": {}
        }
        
        # 1. Calculate text metrics
        logger.info("📊 Calculating text metrics...")
        results["metrics"] = {
            "perplexity": self.metrics.calculate_perplexity(text),
            "burstiness": self.metrics.calculate_burstiness(text),
            "vocabulary_diversity": self.metrics.calculate_vocabulary_diversity(text),
            "text_length": len(text.split()),
            "sentence_count": len(re.split(r'[.!?]+', text))
        }
        
        # 2. Pattern detection
        results["pattern_analysis"] = {
            "ai_patterns_found": self.metrics.detect_ai_patterns(text),
            "human_patterns_found": self.metrics.detect_human_patterns(text)
        }
        
        # 3. Run ModernBERT models
        modernbert_results = []
        for i in range(len(self.modernbert_models)):
            result = self.classify_with_modernbert(text, i)
            if result:
                results["individual_models"].append(result)
                modernbert_results.append(result)
        
        # 4. Run additional models
        for model_name in self.additional_models.keys():
            result = self.classify_with_additional(text, model_name)
            if result:
                results["individual_models"].append(result)
        
        # 5. Calculate ensemble result (weighted average)
        if results["individual_models"]:
            total_ai = 0
            total_human = 0
            weights_sum = 0
            
            for i, result in enumerate(results["individual_models"]):
                # Give ModernBERT models higher weight
                weight = 1.5 if i < len(modernbert_results) else 1.0
                total_ai += result["ai_score"] * weight
                total_human += result["human_score"] * weight
                weights_sum += weight
            
            if weights_sum > 0:
                ensemble_ai = total_ai / weights_sum
                ensemble_human = total_human / weights_sum
            else:
                ensemble_ai = ensemble_human = 50
            
            # Adjust based on metrics
            # High perplexity suggests human text
            if results["metrics"]["perplexity"] > 100:
                ensemble_human += 5
                ensemble_ai -= 5
            elif results["metrics"]["perplexity"] < 30:
                ensemble_ai += 5
                ensemble_human -= 5
            
            # High burstiness suggests human text
            if results["metrics"]["burstiness"] > 0.8:
                ensemble_human += 5
                ensemble_ai -= 5
            elif results["metrics"]["burstiness"] < 0.3:
                ensemble_ai += 5
                ensemble_human -= 5
            
            # Pattern analysis adjustment
            pattern_adjustment = (results["pattern_analysis"]["ai_patterns_found"] - 
                                 results["pattern_analysis"]["human_patterns_found"]) * 3
            ensemble_ai += pattern_adjustment
            ensemble_human -= pattern_adjustment
            
            # Normalize to 100%
            total = ensemble_ai + ensemble_human
            if total > 0:
                ensemble_ai = (ensemble_ai / total) * 100
                ensemble_human = (ensemble_human / total) * 100
            
            # Determine most likely AI model
            if ensemble_ai > ensemble_human and modernbert_results:
                predicted_model = modernbert_results[0]["predicted_model"]
            else:
                predicted_model = "Human"
            
            results["ensemble_result"] = {
                "ai_percentage": round(min(max(ensemble_ai, 0), 100), 2),
                "human_percentage": round(min(max(ensemble_human, 0), 100), 2),
                "predicted_model": predicted_model,
                "confidence": round(max(ensemble_ai, ensemble_human), 2),
                "is_human": ensemble_human > ensemble_ai,
                "models_used": len(results["individual_models"])
            }
        
        return results

# =====================================================
# 🧹 دوال التنظيف والمعالجة
# =====================================================
def clean_text(text: str) -> str:
    """تنظيف النص من المسافات الزائدة"""
    text = re.sub(r'\s{2,}', ' ', text)
    text = re.sub(r'\s+([,.;:?!])', r'\1', text)
    return text.strip()

def split_into_paragraphs(text: str) -> List[str]:
    """تقسيم النص إلى فقرات"""
    paragraphs = re.split(r'\n\s*\n', text.strip())
    return [p.strip() for p in paragraphs if p.strip()]

# =====================================================
# 🌐 FastAPI Application
# =====================================================
app = FastAPI(
    title="Enhanced ModernBERT AI Detector",
    description="Advanced AI detection with multiple models, perplexity, and burstiness analysis",
    version="3.0.0"
)

# إضافة CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# إنشاء مدير الموديلات المحسن
model_manager = EnhancedModelManager()

# =====================================================
# 📝 نماذج البيانات (Pydantic Models)
# =====================================================
class TextInput(BaseModel):
    text: str
    analyze_paragraphs: Optional[bool] = False
    return_individual_scores: Optional[bool] = True

class SimpleTextInput(BaseModel):
    text: str

class EnhancedDetectionResult(BaseModel):
    success: bool
    code: int
    message: str
    data: Dict

# =====================================================
# 🎯 API Endpoints
# =====================================================
@app.on_event("startup")
async def startup_event():
    """تحميل الموديلات عند بداية التشغيل"""
    logger.info("=" * 50)
    logger.info("🚀 Starting Enhanced ModernBERT AI Detector...")
    logger.info(f"🐍 Python version: {sys.version}")
    logger.info(f"🔥 PyTorch version: {torch.__version__}")
    logger.info("=" * 50)
    
    # Load models
    max_modernbert = int(os.environ.get("MAX_MODERNBERT_MODELS", "2"))
    load_additional = os.environ.get("LOAD_ADDITIONAL_MODELS", "true").lower() == "true"
    
    success = model_manager.load_all_models(
        max_modernbert=max_modernbert,
        load_additional=load_additional
    )
    
    if success:
        logger.info("✅ Application ready with enhanced features!")
    else:
        logger.error("⚠️ Failed to load models - API will return errors")

@app.get("/")
async def root():
    """الصفحة الرئيسية"""
    models_info = {
        "modernbert_models": len(model_manager.modernbert_models),
        "additional_models": list(model_manager.additional_models.keys())
    }
    
    return {
        "message": "Enhanced ModernBERT AI Text Detector API",
        "status": "online" if model_manager.models_loaded else "initializing",
        "models": models_info,
        "device": str(device),
        "features": [
            "Multiple AI detection models",
            "Perplexity analysis",
            "Burstiness analysis",
            "Pattern detection",
            "Individual model scores",
            "Ensemble predictions"
        ],
        "endpoints": {
            "analyze": "/analyze",
            "simple": "/analyze-simple",
            "health": "/health",
            "docs": "/docs"
        }
    }

@app.get("/health")
async def health_check():
    """فحص صحة الخدمة"""
    memory_info = {}
    if torch.cuda.is_available():
        memory_info = {
            "gpu_allocated_gb": round(torch.cuda.memory_allocated() / 1024**3, 2),
            "gpu_reserved_gb": round(torch.cuda.memory_reserved() / 1024**3, 2)
        }
    
    return {
        "status": "healthy" if model_manager.models_loaded else "unhealthy",
        "modernbert_models": len(model_manager.modernbert_models),
        "additional_models": len(model_manager.additional_models),
        "total_models": len(model_manager.modernbert_models) + len(model_manager.additional_models),
        "device": str(device),
        "cuda_available": torch.cuda.is_available(),
        "memory_info": memory_info
    }

@app.post("/analyze", response_model=EnhancedDetectionResult)
async def analyze_text_enhanced(data: TextInput):
    """
    Enhanced analysis with multiple models and metrics
    """
    try:
        # Validate input
        text = data.text.strip()
        if not text:
            return EnhancedDetectionResult(
                success=False,
                code=400,
                message="Empty input text",
                data={}
            )
        
        # Ensure models are loaded
        if not model_manager.models_loaded:
            if not model_manager.load_all_models():
                return EnhancedDetectionResult(
                    success=False,
                    code=503,
                    message="Models not available",
                    data={}
                )
        
        # Comprehensive analysis
        analysis_result = model_manager.comprehensive_analysis(text)
        
        # Basic stats
        total_words = len(text.split())
        ai_percentage = analysis_result["ensemble_result"]["ai_percentage"]
        human_percentage = analysis_result["ensemble_result"]["human_percentage"]
        ai_words = int(total_words * (ai_percentage / 100))
        
        # Paragraph analysis if requested
        paragraphs_analysis = []
        if data.analyze_paragraphs:
            paragraphs = split_into_paragraphs(text)
            for para in paragraphs[:10]:
                if para.strip():
                    try:
                        para_result = model_manager.comprehensive_analysis(para)
                        para_words = len(para.split())
                        
                        paragraphs_analysis.append({
                            "paragraph": para[:200] + "..." if len(para) > 200 else para,
                            "ai_generated_score": para_result["ensemble_result"]["ai_percentage"] / 100,
                            "human_written_score": para_result["ensemble_result"]["human_percentage"] / 100,
                            "predicted_model": para_result["ensemble_result"]["predicted_model"],
                            "metrics": {
                                "perplexity": para_result["metrics"]["perplexity"],
                                "burstiness": para_result["metrics"]["burstiness"]
                            }
                        })
                    except Exception as e:
                        logger.warning(f"Failed to analyze paragraph: {e}")
        
        # Prepare response
        response_data = {
            "fakePercentage": ai_percentage,
            "isHuman": human_percentage,
            "textWords": total_words,
            "aiWords": ai_words,
            "predicted_model": analysis_result["ensemble_result"]["predicted_model"],
            "feedback": "Most of Your Text is AI/GPT Generated" if ai_percentage > 50 else "Most of Your Text Appears Human-Written",
            "confidence": analysis_result["ensemble_result"]["confidence"],
            "models_used": analysis_result["ensemble_result"]["models_used"],
            
            # New: Metrics
            "metrics": analysis_result["metrics"],
            
            # New: Pattern analysis
            "pattern_analysis": analysis_result["pattern_analysis"],
            
            # Paragraphs if requested
            "paragraphs": paragraphs_analysis,
            
            # Text preview
            "input_text": text[:500] + "..." if len(text) > 500 else text,
            "detected_language": "en"
        }
        
        # Add individual model scores if requested
        if data.return_individual_scores:
            response_data["individual_models"] = analysis_result["individual_models"]
        
        return EnhancedDetectionResult(
            success=True,
            code=200,
            message="Enhanced analysis completed",
            data=response_data
        )
        
    except Exception as e:
        logger.error(f"Analysis error: {e}", exc_info=True)
        return EnhancedDetectionResult(
            success=False,
            code=500,
            message=f"Analysis failed: {str(e)}",
            data={}
        )

@app.post("/analyze-simple")
async def analyze_simple(data: SimpleTextInput):
    """
    Simple analysis - returns basic results only
    """
    try:
        text = data.text.strip()
        if not text:
            raise HTTPException(status_code=400, detail="Empty text")
        
        if not model_manager.models_loaded:
            if not model_manager.load_all_models():
                raise HTTPException(status_code=503, detail="Models not available")
        
        result = model_manager.comprehensive_analysis(text)
        ensemble = result["ensemble_result"]
        
        return {
            "is_ai": ensemble["ai_percentage"] > 50,
            "ai_score": ensemble["ai_percentage"],
            "human_score": ensemble["human_percentage"],
            "detected_model": ensemble["predicted_model"],
            "confidence": ensemble["confidence"],
            "perplexity": result["metrics"]["perplexity"],
            "burstiness": result["metrics"]["burstiness"]
        }
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Simple analysis error: {e}")
        raise HTTPException(status_code=500, detail=str(e))

# =====================================================
# 🏃 تشغيل التطبيق
# =====================================================
if __name__ == "__main__":
    import uvicorn
    
    port = int(os.environ.get("PORT", 8000))
    host = os.environ.get("HOST", "0.0.0.0")
    workers = int(os.environ.get("WORKERS", 1))
    
    logger.info("=" * 50)
    logger.info(f"🌐 Starting enhanced server on {host}:{port}")
    logger.info(f"👷 Workers: {workers}")
    logger.info(f"📚 Documentation: http://{host}:{port}/docs")
    logger.info("=" * 50)
    
    uvicorn.run(
        "app_enhanced:app",
        host=host,
        port=port,
        reload=False,
        workers=workers,
        log_level="info"
    )