improved_anonymizer (10).py

import gradio as gr
import re
import os
import requests
import time
import logging

# تنظیم logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class UniversalAnonymizer:
    def __init__(self):
        self.mapping_table = {}
        self.counters = {
            'company': 0, 
            'person': 0, 
            'amount': 0, 
            'percent': 0
        }
        self.api_key = os.getenv("OPENAI_API_KEY", "")

    def anonymize_text(self, original_text, lang='fa'):
        """ناشناس‌سازی جامع با تشخیص خودکار الگوها"""
        try:
            if not original_text or not original_text.strip():
                return "⚠ Please enter input text!" if lang == 'en' else "⚠ لطفاً متن ورودی را وارد کنید!"
            
            # ریست متغیرها
            self.mapping_table = {}
            self.counters = {key: 0 for key in self.counters.keys()}
            
            anonymized = original_text
            
            # مرحله 1: درصدها (اول از همه چون ممکن است در توضیحات باشند)
            anonymized = self._anonymize_percentages(anonymized)
            
            # مرحله 2: مبالغ مالی (قبل از شرکت‌ها تا اعداد درون نام شرکت‌ها تغییر نکند)
            anonymized = self._anonymize_amounts(anonymized)
            
            # مرحله 3: نام‌های اشخاص
            anonymized = self._anonymize_persons(anonymized)
            
            # مرحله 4: نام‌های شرکت‌ها
            anonymized = self._anonymize_companies(anonymized)
            
            logger.info(f"✅ Anonymization completed. Found {len(self.mapping_table)} entities.")
            return anonymized
            
        except Exception as e:
            return f"⚠ Error in anonymization: {str(e)}" if lang == 'en' else f"⚠ خطا در ناشناس‌سازی: {str(e)}"
    
    def _anonymize_percentages(self, text):
        """تشخیص و ناشناس‌سازی همه انواع درصدها"""
        
        # الگوهای جامع درصدها
        percent_patterns = [
            # درصدهای منفی
            r'منفی \d+\.?\d* درصد',
            
            # درصدهای با کلمه درصدی
            r'\d+\.?\d* درصدی',
            
            # درصدهای ساده
            r'\d+\.?\d* درصد',
            
            # بازه‌های درصدی
            r'\d+\.?\d* تا \d+\.?\d* درصد',
            r'\d+\.?\d*–\d+\.?\d*٪',
            r'\d+\.?\d*-\d+\.?\d*٪',
            
            # درصدهای با توضیحات
            r'بیش از \d+\.?\d* درصد',
            r'حدود \d+\.?\d* درصد',
            r'نزدیک به \d+\.?\d* درصد',
            r'کمتر از \d+\.?\d* درصد',
            r'بالای \d+\.?\d* درصد',
            r'زیر \d+\.?\d* درصد',
            r'حداقل \d+\.?\d* درصد',
            r'حداکثر \d+\.?\d* درصد',
            
            # نمادهای درصد
            r'\d+\.?\d*%',
            r'\d+\.?\d*٪',
            
            # درصدهای دهگانی
            r'\d+\.\d+ درصد',
            
            # بازه‌هایی با خط فاصله
            r'\d+–\d+٪',
        ]
        
        return self._apply_patterns(text, percent_patterns, 'percent')
    
    def _anonymize_amounts(self, text):
        """تشخیص و ناشناس‌سازی همه انواع مبالغ مالی"""
        
        # الگوهای جامع مبالغ مالی
        amount_patterns = [
            # مبالغ با کاما و نقطه
            r'\d+,\d{3},\d{3} میلیون ریال',
            r'\d+\.\d{3}\.\d{3} میلیون ریال',
            r'\d+,\d{3} میلیارد ریال',
            r'\d+\.\d{3} میلیارد ریال',
            
            # مبالغ با واحد همت
            r'\d+\.?\d* همت',
            r'بیش از \d+\.?\d* همت',
            r'نزدیک به \d+\.?\d* همت',
            r'حدود \d+\.?\d* همت',
            r'کمتر از \d+\.?\d* همت',
            r'بالغ بر \d+\.?\d* همت',
            
            # مبالغ ترکیبی با هزار
            r'\d+ هزار و \d+ میلیارد تومان',
            r'\d+ هزار و \d+ میلیارد ریال',
            r'\d+ هزار و \d+ میلیون تومان',
            r'\d+ هزار و \d+ میلیون ریال',
            r'\d+ هزار و \d+ دستگاه',
            r'\d+ هزار و \d+ تن',
            r'\d+ هزار و \d+ نفر',
            
            # مبالغ با توضیحات
            r'بیش از \d+ هزار میلیارد تومان',
            r'نزدیک به \d+ هزار میلیارد تومان',
            r'حدود \d+ هزار میلیارد تومان',
            r'کمتر از \d+ هزار میلیارد تومان',
            r'بالغ بر \d+ هزار میلیارد تومان',
            
            r'بیش از \d+ میلیارد تومان',
            r'نزدیک به \d+ میلیارد تومان',
            r'حدود \d+ میلیارد تومان',
            r'کمتر از \d+ میلیارد تومان',
            r'بالغ بر \d+ میلیارد تومان',
            
            r'بیش از \d+ میلیون تومان',
            r'حدود \d+ میلیون تومان',
            r'نزدیک به \d+ میلیون تومان',
            
            # مبالغ ارزی
            r'حدود \d+ میلیون دلار',
            r'بیش از \d+ میلیون دلار',
            r'نزدیک به \d+ میلیون دلار',
            r'\d+ میلیون دلار',
            r'\d+ میلیون یورو',
            
            # مبالغ خاص
            r'یک‌هزار میلیارد تومان',
            r'یکهزار میلیارد تومان',
            r'دویست میلیارد تومان',
            r'سیصد میلیارد تومان',
            r'چهارصد میلیارد تومان',
            r'پانصد میلیارد تومان',
            
            # مبالغ با کاما
            r'\d+,\d+ میلیارد تومان',
            r'\d+,\d+ میلیارد ریال',
            r'\d+,\d+ میلیون تومان',
            r'\d+,\d+ میلیون ریال',
            r'\d+,\d+ هزار میلیارد تومان',
            r'\d+,\d+ هزار میلیارد ریال',
            
            # مبالغ ساده
            r'\d+ میلیارد تومان',
            r'\d+ میلیارد ریال',
            r'\d+ میلیون تومان',
            r'\d+ میلیون ریال',
            r'\d+ هزار میلیارد تومان',
            r'\d+ هزار میلیارد ریال',
            r'\d+ هزارمیلیارد تومان',
            r'\d+ هزارمیلیون تومان',
            r'\d+ ریال',
            r'\d+ تومان',
            
            # واحدهای تولیدی و اندازه‌گیری
            r'\d+ هزار تن',
            r'\d+,\d+ هزار تن',
            r'\d+ میلیون تن',
            r'\d+ تن',
            r'\d+ مگا واتی',
            r'\d+ مگاوات',
            r'\d+ کیلووات',
            r'\d+ واحد',
            r'\d+ دستگاه',
            r'\d+ میلیون دستگاه',
            r'\d+ هزار دستگاه',
            
            # تعداد افراد
            r'\d+\.?\d* میلیون نفر',
            r'\d+ میلیون نفر',
            r'\d+ هزار نفر',
            r'\d+ نفر',
            
            # مبالغ اعشاری
            r'\d+\.\d+ میلیارد تومان',
            r'\d+\.\d+ میلیارد ریال',
            r'\d+\.\d+ میلیون تومان',
            r'\d+\.\d+ میلیون ریال',
            r'\d+\.\d+ هزار میلیارد تومان',
            r'\d+\.\d+ هزار میلیارد ریال',
            r'\d+\.\d+ همت',
            
            # بازه‌های مقداری
            r'\d+ تا \d+ میلیارد تومان',
            r'\d+ تا \d+ میلیون تومان',
            r'\d+ تا \d+ ماه',
            r'\d+ تا \d+ سال',
            r'\d+ الی \d+ میلیارد تومان',
        ]
        
        return self._apply_patterns(text, amount_patterns, 'amount')
    
    def _anonymize_persons(self, text):
        """تشخیص و ناشناس‌سازی همه انواع نام‌های اشخاص"""
        
        # الگوهای جامع نام‌های اشخاص
        person_patterns = [
            # نام‌های کامل با عناوین
            r'دکتر\s+[آ-ی]+\s+[آ-ی]+\s+[آ-ی]+',
            r'مهندس\s+[آ-ی]+\s+[آ-ی]+\s+[آ-ی]+',
            r'آقای\s+[آ-ی]+\s+[آ-ی]+\s+[آ-ی]+',
            r'خانم\s+[آ-ی]+\s+[آ-ی]+\s+[آ-ی]+',
            
            # نام‌های کامل با سید
            r'سید\s+[آ-ی]+\s+[آ-ی]+',
            r'سید\s+[آ-ی]+\s+[آ-ی]+\s+[آ-ی]+',
            r'سیدعلی\s+[آ-ی]+',
            r'سیدمحمد\s+[آ-ی]+',
            r'سیدحسن\s+[آ-ی]+',
            
            # نام و نام خانوادگی ساده
            r'[آ-ی]{3,}\s+[آ-ی]{3,}(?:\s+[آ-ی]{3,})?',
            
            # نام‌هایی که با مدیرعامل همراه هستند
            r'[آ-ی]+\s+[آ-ی]+\s*،?\s*مدیرعامل',
            r'[آ-ی]+\s+[آ-ی]+\s+[آ-ی]+\s*،?\s*مدیرعامل',
            
            # نام‌هایی که با سمت همراه هستند
            r'[آ-ی]+\s+[آ-ی]+\s*،?\s*رئیس',
            r'[آ-ی]+\s+[آ-ی]+\s*،?\s*مدیر',
            r'[آ-ی]+\s+[آ-ی]+\s*،?\s*نایب',
            
            # نام‌های خاص (باید در آخر باشند تا اولویت کمتری داشته باشند)
            r'محمدرضا\s+[آ-ی]+',
            r'علیرضا\s+[آ-ی]+',
            r'محمدعلی\s+[آ-ی]+',
            r'حسینعلی\s+[آ-ی]+',
        ]
        
        return self._apply_patterns(text, person_patterns, 'person')
    
    def _anonymize_companies(self, text):
        """تشخیص و ناشناس‌سازی همه انواع نام‌های شرکت‌ها"""
        
        # الگوهای جامع نام‌های شرکت‌ها
        company_patterns = [
            # شرکت‌های کامل با پرانتز
            r'شرکت\s+[آ-ی\s]+\([آ-ی\s]+\)',
            r'بانک\s+[آ-ی\s]+\([آ-ی\s]+\)',
            r'گروه\s+[آ-ی\s]+\([آ-ی\s]+\)',
            r'هلدینگ\s+[آ-ی\s]+\([آ-ی\s]+\)',
            
            # شرکت‌های با کلمه شرکت
            r'شرکت\s+[آ-ی\s]{5,}',
            r'شرکت\s+گروه\s+[آ-ی\s]+',
            r'شرکت\s+سرمایه‌گذاری\s+[آ-ی\s]+',
            r'شرکت\s+بیمه\s+[آ-ی\s]+',
            r'شرکت\s+پتروشیمی\s+[آ-ی\s]+',
            r'شرکت\s+فولاد\s+[آ-ی\s]+',
            r'شرکت\s+پالایش\s+[آ-ی\s]+',
            r'شرکت\s+انرژی\s+[آ-ی\s]+',
            r'شرکت\s+ملی\s+[آ-ی\s]+',
            
            # بانک‌ها
            r'بانک\s+[آ-ی\s]{3,}',
            r'موسسه\s+اعتباری\s+[آ-ی\s]+',
            r'موسسه\s+مالی\s+[آ-ی\s]+',
            
            # گروه‌ها و هلدینگ‌ها
            r'گروه\s+[آ-ی\s]{3,}',
            r'هلدینگ\s+[آ-ی\s]{3,}',
            r'گروه\s+مالی\s+[آ-ی\s]+',
            r'گروه\s+صنعتی\s+[آ-ی\s]+',
            
            # صندوق‌ها و سازمان‌ها
            r'صندوق\s+[آ-ی\s]{3,}',
            r'سازمان\s+[آ-ی\s]{3,}',
            r'موسسه\s+[آ-ی\s]{3,}',
            
            # شرکت‌های خاص
            r'[آ-ی]+\s+خودرو',
            r'[آ-ی]+\s+فولاد',
            r'بیمه\s+[آ-ی]+',
            r'[آ-ی]+\s+انرژی',
            r'[آ-ی]+\s+پتروشیمی',
            
            # نام‌های کوتاه شرکت‌ها (باید در آخر باشند)
            r'همراه\s+اول',
            r'ایران\s*[-‌]*\s*خودرو',
            r'فولاد\s+مبارکه',
            
            # مجله‌ها و نشریات
            r'مجله\s+[آ-ی\s]+',
            r'نشریه\s+[آ-ی\s]+',
            r'روزنامه\s+[آ-ی\s]+',
        ]
        
        return self._apply_patterns(text, company_patterns, 'company')
    
    def _apply_patterns(self, text, patterns, category):
        """اعمال الگوها و جایگزینی با کدهای ناشناس"""
        
        # مرتب‌سازی الگوها بر اساس طول (طولانی‌ترین اول)
        patterns.sort(key=len, reverse=True)
        
        for pattern in patterns:
            matches = list(re.finditer(pattern, text, re.IGNORECASE))
            
            for match in matches:
                matched_text = match.group(0)
                
                # اگر قبلاً جایگزین نشده باشد
                if matched_text not in self.mapping_table and matched_text in text:
                    # بررسی که کلمه کامل باشد (نه بخشی از کلمه بزرگ‌تر)
                    if self._is_complete_word(text, match):
                        self.counters[category] += 1
                        code = f"{category}-{self.counters[category]:02d}"
                        self.mapping_table[matched_text] = code
                        text = text.replace(matched_text, code)
                        logger.info(f"{category.title()} replaced: {matched_text} -> {code}")
        
        return text
    
    def _is_complete_word(self, text, match):
        """بررسی اینکه آیا کلمه کامل است یا بخشی از کلمه بزرگ‌تر"""
        start, end = match.span()
        
        # بررسی کاراکتر قبل و بعد
        if start > 0 and text[start-1].isalnum():
            return False
        if end < len(text) and text[end].isalnum():
            return False
            
        return True

    def send_to_chatgpt(self, anonymized_text, lang='fa'):
        """ارسال به ChatGPT"""
        try:
            if not anonymized_text or not anonymized_text.strip():
                return "⚠ Anonymized text is empty!" if lang == 'en' else "⚠ متن ناشناس‌شده خالی است!"
            
            if not self.api_key:
                return "⚠ API Key not configured! Please set OPENAI_API_KEY environment variable." if lang == 'en' else "⚠ کلید API تنظیم نشده است! لطفاً OPENAI_API_KEY را در متغیرهای محیطی تنظیم کنید."
            
            system_msg = "You are a professional financial analyst. The text contains anonymous codes. Answer questions accurately." if lang == 'en' else "شما یک تحلیلگر مالی حرفه‌ای هستید. متن حاوی کدهای ناشناس است. به سوالات با دقت پاسخ دهید."
            
            headers = {
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            }
            
            data = {
                "model": "gpt-4o-mini",
                "messages": [
                    {"role": "system", "content": system_msg},
                    {"role": "user", "content": anonymized_text}
                ],
                "max_tokens": 2000,
                "temperature": 0.7
            }
            
            response = requests.post(
                "https://api.openai.com/v1/chat/completions",
                headers=headers,
                json=data,
                timeout=30
            )
            
            if response.status_code == 200:
                result = response.json()
                return result['choices'][0]['message']['content']
            else:
                error_data = response.json() if response.content else {}
                error_message = error_data.get('error', {}).get('message', response.text)
                
                if 'Incorrect API key' in error_message:
                    return "⚠ Invalid API key." if lang == 'en' else "⚠ کلید API نامعتبر است."
                elif 'quota' in error_message:
                    return "⚠ API quota exceeded." if lang == 'en' else "⚠ سهمیه API تمام شده است."
                else:
                    return f"⚠ API Error: {error_message}"
                
        except Exception as e:
            return f"⚠ Error connecting to ChatGPT: {str(e)}" if lang == 'en' else f"⚠ خطا در ارتباط با ChatGPT: {str(e)}"

    def deanonymize_response(self, gpt_response, lang='fa'):
        """بازگردانی"""
        try:
            if not gpt_response or not gpt_response.strip():
                return "⚠ ChatGPT response is empty!" if lang == 'en' else "⚠ پاسخ ChatGPT خالی است!"
            
            if not self.mapping_table:
                return "⚠ Mapping table is empty!" if lang == 'en' else "⚠ جدول نگاشت خالی است!"
            
            final_result = gpt_response
            reverse_mapping = {code: original for original, code in self.mapping_table.items()}
            
            # جایگزینی از طولانی‌ترین کد اول
            sorted_codes = sorted(reverse_mapping.items(), key=lambda x: len(x[0]), reverse=True)
            for code, original in sorted_codes:
                final_result = final_result.replace(code, original)
            
            return final_result
            
        except Exception as e:
            return f"⚠ Deanonymization error: {str(e)}" if lang == 'en' else f"⚠ خطا در بازگردانی: {str(e)}"

def process_all_steps(input_text, language):
    """پردازش خودکار تمام مراحل"""
    lang = 'en' if language == 'English' else 'fa'
    
    if not input_text.strip():
        error_msg = "⚠ Please enter input text!" if lang == 'en' else "⚠ لطفاً متن ورودی را وارد کنید!"
        return error_msg, "", "", ""
    
    try:
        start_time = time.time()
        
        anonymized_text = anonymizer.anonymize_text(input_text, lang)
        if anonymized_text.startswith("⚠"):
            return anonymized_text, "", "", ""
        
        gpt_response = anonymizer.send_to_chatgpt(anonymized_text, lang)
        if gpt_response.startswith("⚠"):
            entities_found = len(anonymizer.mapping_table)
            success_msg = (f"✅ Anonymization completed!\n"
                          f"📊 Total: {entities_found} entities protected")
            return success_msg, anonymized_text, gpt_response, ""
        
        final_result = anonymizer.deanonymize_response(gpt_response, lang)
        
        total_time = time.time() - start_time
        entities_found = len(anonymizer.mapping_table)
        
        # آمار تفصیلی
        company_count = anonymizer.counters['company']
        amount_count = anonymizer.counters['amount']
        percent_count = anonymizer.counters['percent']
        person_count = anonymizer.counters['person']
        
        success_msg = (f"🎉 Universal anonymization & restoration successful!\n"
                      f"🏢 Companies: {company_count} | 💰 Amounts: {amount_count} | 📊 Percentages: {percent_count} | 👤 Persons: {person_count}\n"
                      f"📊 Total: {entities_found} entities | ⏱️ Time: {total_time:.2f}s")
        
        return success_msg, anonymized_text, gpt_response, final_result
        
    except Exception as e:
        error_msg = f"⚠ Processing error: {str(e)}" if lang == 'en' else f"⚠ خطا در پردازش: {str(e)}"
        return error_msg, "", "", ""

def get_mapping_table(language):
    """نمایش جدول نگاشت"""
    lang = 'en' if language == 'English' else 'fa'
    
    if not anonymizer.mapping_table:
        return "⚠ Mapping table is empty! Please process some text first." if lang == 'en' else "⚠ جدول نگاشت خالی است! ابتدا متنی را پردازش کنید."
    
    result = "📋 **Universal Mapping Table:**\n\n" if lang == 'en' else "📋 **جدول نگاشت جامع:**\n\n"
    
    # گروه‌بندی بر اساس نوع
    categories = {
        'company': '🏢 **Companies**',
        'amount': '💰 **Amounts**',
        'percent': '📊 **Percentages**',
        'person': '👤 **Persons**'
    }
    
    for category, title in categories.items():
        category_items = {k: v for k, v in anonymizer.mapping_table.items() if v.startswith(category)}
        if category_items:
            result += f"{title}:\n"
            for original, code in category_items.items():
                result += f"   • `{original}` → `{code}`\n"
            result += "\n"
    
    # آمار کلی
    result += f"📊 **Summary**: {len(anonymizer.mapping_table)} total entities anonymized\n"
    
    return result

def clear_all():
    """پاک کردن همه"""
    anonymizer.mapping_table = {}
    anonymizer.counters = {key: 0 for key in anonymizer.counters.keys()}
    return "", "", "", "", ""

def update_ui_text(language):
    """به‌روزرسانی متن‌های رابط کاربری"""
    if language == 'English':
        return {
            'title': 'Universal Business Data Anonymization System',
            'step1': 'Input Text & Settings',
            'step2': 'Anonymized Text',
            'step3': 'Raw ChatGPT Response',
            'step4': 'Final Restored Response',
            'input_placeholder': 'Enter your business text here...\nThe system will automatically detect and anonymize all types of company names, financial amounts, percentages, and personal names using advanced pattern recognition...',
            'process_btn': 'Process with Universal Detection',
            'clear_btn': 'Clear All',
            'mapping_btn': 'Show Universal Mapping Table',
            'direction': 'ltr'
        }
    else:
        return {
            'title': 'سیستم ناشناس‌سازی جامع اطلاعات تجاری',
            'step1': 'متن ورودی و تنظیمات',
            'step2': 'متن ناشناس‌شده',
            'step3': 'پاسخ خام ChatGPT',
            'step4': 'پاسخ نهایی بازگردانده شده',
            'input_placeholder': 'متن تجاری خود را اینجا وارد کنید...\nسیستم به صورت خودکار تمام انواع نام شرکت‌ها، مبالغ مالی، درصدها و نام‌های اشخاص را با تشخیص الگوی پیشرفته شناسایی و ناشناس می‌کند...',
            'process_btn': 'پردازش با تشخیص جامع',
            'clear_btn': 'پاک کردن همه',
            'mapping_btn': 'نمایش جدول نگاشت جامع',
            'direction': 'rtl'
        }

def update_interface(language):
    """تغییر رابط کاربری بر اساس زبان"""
    ui_text = update_ui_text(language)
    is_english = (language == 'English')
    
    workflow_css = "workflow ltr" if is_english else "workflow rtl"
    
    return [
        gr.update(value=f"<h1 style='text-align: center; color: #FFD700; font-size: 3.5em; font-weight: bold; text-shadow: 3px 3px 6px rgba(0,0,0,0.5); margin: 20px 0; background: linear-gradient(45deg, #FFD700, #FFA500); -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text;'>📊 {ui_text['title']}</h1>"),
        gr.update(value=f"<h2 style='direction: {ui_text['direction']};'>🔍 {ui_text['step1']}</h2>"),
        gr.update(placeholder=ui_text['input_placeholder'], rtl=not is_english),
        gr.update(value=f"🚀 {ui_text['process_btn']}"),
        gr.update(value=f"🗑️ {ui_text['clear_btn']}"),
        gr.update(rtl=not is_english),
        gr.update(value=f"<h2 style='direction: {ui_text['direction']};'>🎭 {ui_text['step2']}</h2>"),
        gr.update(rtl=not is_english),
        gr.update(value=f"<h2 style='direction: {ui_text['direction']};'>🤖 {ui_text['step3']}</h2>"),
        gr.update(rtl=not is_english),
        gr.update(value=f"<h2 style='direction: {ui_text['direction']};'>✅ {ui_text['step4']}</h2>"),
        gr.update(rtl=not is_english),
        gr.update(value=f"📋 {ui_text['mapping_btn']}"),
        gr.update(rtl=not is_english),
        gr.update(elem_classes=workflow_css)
    ]

# ایجاد instance
anonymizer = UniversalAnonymizer()

# CSS
custom_css = """
body, .gradio-container {
    font-family: 'Segoe UI', Tahoma, Arial, sans-serif !important;
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
    min-height: 100vh !important;
    padding: 20px !important;
}

.rtl {
    direction: rtl !important;
    text-align: right !important;
}

.ltr {
    direction: ltr !important;
    text-align: left !important;
}

.workflow {
    display: grid !important;
    grid-template-columns: 1fr 1fr 1fr 1fr !important;
    gap: 25px !important;
    padding: 30px !important;
    align-items: start !important;
    align-content: start !important;
    grid-auto-rows: auto !important;
}

.gradio-textbox {
    border-radius: 10px !important;
    box-shadow: 0 4px 15px rgba(0,0,0,0.1) !important;
    min-height: 380px !important;
    max-height: 380px !important;
    height: 380px !important;
}

.gradio-textbox textarea {
    min-height: 350px !important;
    max-height: 350px !important;
    height: 350px !important;
    resize: vertical !important;
}

.status-box {
    background: linear-gradient(135deg, #4CAF50, #45a049) !important;
    border: 3px solid #2E7D32 !important;
    border-radius: 15px !important;
    padding: 15px !important;
    margin: 10px 0 !important;
    box-shadow: 0 8px 32px rgba(76, 175, 80, 0.3) !important;
    animation: pulse 2s infinite !important;
    min-height: 120px !important;
    max-height: 120px !important;
}

@keyframes pulse {
    0% { box-shadow: 0 8px 32px rgba(76, 175, 80, 0.3); }
    50% { box-shadow: 0 8px 40px rgba(76, 175, 80, 0.6); }
    100% { box-shadow: 0 8px 32px rgba(76, 175, 80, 0.3); }
}

.gradio-button {
    border-radius: 25px !important;
    font-weight: bold !important;
    transition: all 0.3s ease !important;
    margin: 5px 0 !important;
    min-height: 50px !important;
    max-height: 50px !important;
}

h1 {
    background: linear-gradient(45deg, #FFD700, #FFA500) !important;
    -webkit-background-clip: text !important;
    -webkit-text-fill-color: transparent !important;
    background-clip: text !important;
    min-height: 80px !important;
}
"""

# رابط کاربری Gradio
with gr.Blocks(title="📊 Universal Anonymization System", theme=gr.themes.Soft(), css=custom_css) as app:
    
    with gr.Row():
        language_selector = gr.Radio(
            choices=["فارسی", "English"],
            value="فارسی",
            label="Language / زبان",
            interactive=True
        )
    
    with gr.Column():
        title = gr.HTML("<h1 style='text-align: center; color: #FFD700; font-size: 3.5em; font-weight: bold; text-shadow: 3px 3px 6px rgba(0,0,0,0.5); margin: 20px 0; background: linear-gradient(45deg, #FFD700, #FFA500); -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text;'>📊 سیستم ناشناس‌سازی جامع اطلاعات تجاری</h1>")
        
        with gr.Row(elem_classes="workflow rtl") as workflow_row:
            with gr.Column():
                step1_title = gr.HTML('<h2 style="direction: rtl;">🔍 متن ورودی و تنظیمات</h2>')
                
                input_text = gr.Textbox(
                    lines=15,
                    placeholder="متن تجاری خود را اینجا وارد کنید...\nسیستم به صورت خودکار تمام انواع نام شرکت‌ها، مبالغ مالی، درصدها و نام‌های اشخاص را با تشخیص الگوی پیشرفته شناسایی و ناشناس می‌کند...",
                    label="",
                    rtl=True
                )
                
                process_btn = gr.Button("🚀 پردازش با تشخیص جامع", variant="primary")
                clear_btn = gr.Button("🗑️ پاک کردن همه", variant="stop")
                
                status = gr.Textbox(
                    label="وضعیت",
                    lines=4,
                    interactive=False,
                    rtl=True,
                    elem_classes=["status-box"]
                )

            with gr.Column():
                step2_title = gr.HTML('<h2 style="direction: rtl;">🎭 متن ناشناس‌شده</h2>')
                
                anonymized_output = gr.Textbox(
                    lines=15,
                    placeholder="متن ناشناس‌شده اینجا نمایش داده می‌شود...",
                    label="",
                    interactive=False,
                    rtl=True
                )

            with gr.Column():
                step3_title = gr.HTML('<h2 style="direction: rtl;">🤖 پاسخ خام ChatGPT</h2>')
                
                gpt_output = gr.Textbox(
                    lines=15,
                    placeholder="پاسخ خام ChatGPT اینجا نمایش داده می‌شود...",
                    label="",
                    interactive=False,
                    rtl=True
                )

            with gr.Column():
                step4_title = gr.HTML('<h2 style="direction: rtl;">✅ پاسخ نهایی بازگردانده شده</h2>')
                
                final_output = gr.Textbox(
                    lines=15,
                    placeholder="پاسخ نهایی اینجا نمایش داده می‌شود...",
                    label="",
                    interactive=False,
                    rtl=True
                )

        with gr.Row():
            with gr.Column():
                mapping_title = gr.HTML('<h2>🗂️ جدول نگاشت جامع</h2>')
                mapping_btn = gr.Button("📋 نمایش جدول نگاشت جامع")
                
                mapping_output = gr.Textbox(
                    lines=10,
                    label="جدول نگاشت اطلاعات",
                    interactive=False,
                    visible=False,
                    rtl=True
                )

    # Event handlers
    language_selector.change(
        fn=update_interface,
        inputs=[language_selector],
        outputs=[title, step1_title, input_text, process_btn, clear_btn, 
                status, step2_title, anonymized_output, step3_title, gpt_output, 
                step4_title, final_output, mapping_btn, mapping_output, workflow_row]
    )

    process_btn.click(
        fn=process_all_steps,
        inputs=[input_text, language_selector],
        outputs=[status, anonymized_output, gpt_output, final_output]
    )

    clear_btn.click(
        fn=clear_all,
        outputs=[input_text, anonymized_output, gpt_output, final_output, status]
    )

    mapping_btn.click(
        fn=get_mapping_table,
        inputs=[language_selector],
        outputs=[mapping_output]
    )

    mapping_btn.click(
        fn=lambda: gr.update(visible=True),
        outputs=[mapping_output]
    )

if __name__ == "__main__":
    # تست سیستم با نمونه از داده‌های شما
    test_text = """مهدی اخوان بهابادی، مدیرعامل همراه اول، در مجمع عمومی عادی سالیانه اعلام کرد درآمد عملیاتی شرکت اصلی با رشد قابل توجه 37 درصدی نسبت به سال 1402، به 70 هزار و 677 میلیارد تومان رسیده است. شرکت گروه توسعه مالی مهر آیندگان (ومهان) در گزارش عملکرد مردادماه 1404 بار دیگر توانست با رشد 14 درصدی سرمایه‌گذاری‌ها جایگاه خود را تثبیت کند."""
    
    anonymizer_test = UniversalAnonymizer()
    result = anonymizer_test.anonymize_text(test_text)
    print("نتیجه ناشناس‌سازی جامع:")
    print(result)
    print("\nجدول نگاشت:")
    for original, code in anonymizer_test.mapping_table.items():
        print(f"{original} -> {code}")
    
    app.launch()