Upload 46 files

app.py

@@ -0,0 +1,168 @@
+import streamlit as st
+import sys
+from pathlib import Path
+
+# إضافة مسار المشروع للنظام
+sys.path.append(str(Path(__file__).parent.parent))
+
+# استيراد الوحدات
+from modules.document_analysis.document_app import DocumentAnalysisApp
+from modules.pricing.pricing_app import PricingApp
+from modules.resources.resources_app import ResourcesApp
+from modules.risk_analysis.risk_analyzer import RiskAnalysisApp
+from modules.project_management.project_management_app import ProjectsApp
+from modules.maps.maps_app import MapsApp
+from modules.notifications.notifications_app import NotificationsApp
+from modules.document_comparison.document_comparison_app import DocumentComparisonApp
+from modules.translation.translation_app import TranslationApp
+from modules.ai_assistant.ai_app import AIAssistantApp
+from modules.data_analysis.data_analysis_app import DataAnalysisApp
+from styling.enhanced_ui import UIEnhancer
+
+# تكوين الصفحة
+st.set_page_config(
+    page_title="نظام تحليل المناقصات",
+    page_icon="📊",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    menu_items={
+        'Get Help': 'https://www.example.com/help',
+        'Report a bug': "https://www.example.com/bug",
+        'About': "### نظام تحليل المناقصات\nالإصدار 2.0.0"
+    }
+)
+
+# تطبيق التنسيق العام
+ui_enhancer = UIEnhancer(page_title="نظام تحليل المناقصات", page_icon="📊")
+ui_enhancer.apply_global_styles()
+
+# إنشاء قائمة العناصر
+menu_items = [
+    {"name": "لوحة المعلومات", "icon": "house"},
+    {"name": "المناقصات والعقود", "icon": "file-text"},
+    {"name": "تحليل المستندات", "icon": "file-earmark-text"},
+    {"name": "نظام التسعير", "icon": "calculator"},
+    {"name": "حاسبة تكاليف البناء", "icon": "building"},
+    {"name": "الموارد والتكاليف", "icon": "people"},
+    {"name": "تحليل المخاطر", "icon": "exclamation-triangle"},
+    {"name": "إدارة المشاريع", "icon": "kanban"},
+    {"name": "الخرائط والمواقع", "icon": "geo-alt"},
+    {"name": "الجدول الزمني", "icon": "calendar3"},
+    {"name": "الإشعارات", "icon": "bell"},
+    {"name": "مقارنة المستندات", "icon": "files"},
+    {"name": "الترجمة", "icon": "translate"},
+    {"name": "المساعد الذكي", "icon": "robot"},
+    {"name": "تحليل البيانات", "icon": "bar-chart"},
+    {"name": "الإعدادات", "icon": "gear"}
+]
+
+# إنشاء الشريط الجانبي
+selected = ui_enhancer.create_sidebar(menu_items)
+
+# تحديد الوحدة المطلوبة بناءً على اختيار المستخدم
+if selected == "لوحة المعلومات":
+    ui_enhancer.create_header("لوحة المعلومات", "نظرة عامة على المناقصات والمشاريع")
+    
+    # عرض لوحة المعلومات
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        ui_enhancer.create_metric_card("المناقصات النشطة", "12", "+3", ui_enhancer.COLORS['primary'])
+    
+    with col2:
+        ui_enhancer.create_metric_card("المشاريع قيد التنفيذ", "8", "+1", ui_enhancer.COLORS['success'])
+    
+    with col3:
+        ui_enhancer.create_metric_card("المناقصات المقدمة", "24", "+5", ui_enhancer.COLORS['info'])
+    
+    # عرض الإشعارات الأخيرة
+    st.markdown("### الإشعارات الأخيرة")
+    
+    notifications = [
+        {"title": "موعد تقديم مناقصة", "project": "إنشاء مبنى مستشفى الولادة والأطفال", "date": "2025-04-05", "priority": "عالية"},
+        {"title": "تحديث مستندات", "project": "صيانة وتطوير طريق الملك عبدالله", "date": "2025-03-28", "priority": "متوسطة"},
+        {"title": "اجتماع مراجعة التسعير", "project": "إنشاء محطة معالجة مياه الصرف الصحي", "date": "2025-03-25", "priority": "عالية"}
+    ]
+    
+    for notification in notifications:
+        with st.container():
+            col1, col2 = st.columns([4, 1])
+            with col1:
+                st.markdown(f"**{notification['title']}** - {notification['project']}")
+                st.caption(f"التاريخ: {notification['date']} | الأولوية: {notification['priority']}")
+            with col2:
+                st.button("عرض", key=f"view_{notification['title']}")
+            st.divider()
+
+elif selected == "تحليل المستندات":
+    document_app = DocumentAnalysisApp()
+    document_app.run()
+
+elif selected == "نظام التسعير":
+    pricing_app = PricingApp()
+    pricing_app.run()
+
+elif selected == "الموارد والتكاليف":
+    resources_app = ResourcesApp()
+    resources_app.run()
+
+elif selected == "تحليل المخاطر":
+    risk_app = RiskAnalysisApp()
+    risk_app.run()
+
+elif selected == "إدارة المشاريع":
+    projects_app = ProjectsApp()
+    projects_app.run()
+
+elif selected == "الخرائط والمواقع":
+    maps_app = MapsApp()
+    maps_app.run()
+
+elif selected == "الإشعارات":
+    notifications_app = NotificationsApp()
+    notifications_app.run()
+
+elif selected == "مقارنة المستندات":
+    document_comparison_app = DocumentComparisonApp()
+    document_comparison_app.run()
+
+elif selected == "الترجمة":
+    translation_app = TranslationApp()
+    translation_app.run()
+
+elif selected == "المساعد الذكي":
+    ai_app = AIAssistantApp()
+    ai_app.run()
+
+elif selected == "تحليل البيانات":
+    data_analysis_app = DataAnalysisApp()
+    data_analysis_app.run()
+
+elif selected == "الإعدادات":
+    ui_enhancer.create_header("الإعدادات", "إعدادات النظام والحساب")
+    
+    # عرض إعدادات النظام
+    st.markdown("### إعدادات النظام")
+    
+    tabs = st.tabs(["إعدادات عامة", "الواجهة", "الأمان", "مفاتيح API"])
+    
+    with tabs[0]:
+        st.checkbox("تفعيل الإشعارات", value=True)
+        st.checkbox("حفظ تلقائي للبيانات", value=True)
+        st.selectbox("اللغة", ["العربية", "English"])
+        st.selectbox("المنطقة الزمنية", ["توقيت الرياض (GMT+3)", "توقيت جرينتش (GMT)"])
+    
+    with tabs[1]:
+        st.radio("النمط", ["فاتح", "داكن", "تلقائي (حسب نظام التشغيل)"])
+        st.slider("حجم الخط", 12, 20, 16)
+        st.color_picker("لون التمييز", "#1E88E5")
+    
+    with tabs[2]:
+        st.checkbox("تفعيل المصادقة الثنائية", value=False)
+        st.number_input("مدة الجلسة (دقائق)", min_value=5, max_value=120, value=30)
+        st.button("تغيير كلمة المرور")
+    
+    with tabs[3]:
+        st.text_input("مفتاح OpenAI API", type="password")
+        st.text_input("مفتاح Google Maps API", type="password")
+        st.button("حفظ مفاتيح API")

config.py

@@ -0,0 +1,229 @@
+"""
+ملف الإعدادات لنظام إدارة المناقصات
+"""
+
+import os
+import json
+from pathlib import Path
+
+class AppConfig:
+    """فئة إعدادات التطبيق"""
+    
+    def __init__(self):
+        """تهيئة الإعدادات"""
+        # المسارات الأساسية
+        self.app_dir = os.path.dirname(os.path.abspath(__file__))
+        self.assets_dir = os.path.join(self.app_dir, "assets")
+        self.data_dir = os.path.join(self.app_dir, "data")
+        
+        # إنشاء المجلدات إذا لم تكن موجودة
+        Path(self.assets_dir).mkdir(parents=True, exist_ok=True)
+        Path(self.data_dir).mkdir(parents=True, exist_ok=True)
+        
+        # مسارات الأصول
+        self.icons_dir = os.path.join(self.assets_dir, "icons")
+        self.images_dir = os.path.join(self.assets_dir, "images")
+        self.fonts_dir = os.path.join(self.assets_dir, "fonts")
+        
+        # إنشاء مجلدات الأصول إذا لم تكن موجودة
+        Path(self.icons_dir).mkdir(parents=True, exist_ok=True)
+        Path(self.images_dir).mkdir(parents=True, exist_ok=True)
+        Path(self.fonts_dir).mkdir(parents=True, exist_ok=True)
+        
+        # مسارات البيانات
+        self.database_file = os.path.join(self.data_dir, "database.db")
+        self.settings_file = os.path.join(self.data_dir, "settings.json")
+        self.charts_dir = os.path.join(self.data_dir, "charts")
+        
+        # إنشاء مجلد الرسوم البيانية إذا لم يكن موجودًا
+        Path(self.charts_dir).mkdir(parents=True, exist_ok=True)
+        
+        # تحميل الإعدادات
+        self.settings = self._load_settings()
+    
+    def _load_settings(self):
+        """تحميل الإعدادات من ملف JSON"""
+        default_settings = {
+            "app": {
+                "name": "نظام إدارة المناقصات",
+                "version": "1.0.0",
+                "language": "ar",
+                "theme": "light",
+                "font": "Cairo",
+                "font_size": 12
+            },
+            "database": {
+                "type": "sqlite",
+                "path": self.database_file
+            },
+            "ui": {
+                "window_width": 1200,
+                "window_height": 800,
+                "sidebar_width": 250
+            },
+            "notifications": {
+                "enabled": True,
+                "email_enabled": True,
+                "email_server": "smtp.example.com",
+                "email_port": 587,
+                "email_username": "",
+                "email_password": ""
+            },
+            "reports": {
+                "default_format": "pdf",
+                "default_path": os.path.join(self.data_dir, "reports")
+            },
+            "backup": {
+                "auto_backup": True,
+                "backup_frequency": "weekly",
+                "backup_path": os.path.join(self.data_dir, "backups"),
+                "max_backups": 10
+            }
+        }
+        
+        # إذا كان ملف الإعدادات موجودًا، قم بتحميله
+        if os.path.exists(self.settings_file):
+            try:
+                with open(self.settings_file, "r", encoding="utf-8") as f:
+                    settings = json.load(f)
+                
+                # دمج الإعدادات المحملة مع الإعدادات الافتراضية
+                self._merge_settings(default_settings, settings)
+                return default_settings
+            except Exception as e:
+                print(f"خطأ في تحميل الإعدادات: {str(e)}")
+                return default_settings
+        else:
+            # إنشاء ملف الإعدادات الافتراضية
+            self._save_settings(default_settings)
+            return default_settings
+    
+    def _merge_settings(self, default_settings, loaded_settings):
+        """دمج الإعدادات المحملة مع الإعدادات الافتراضية"""
+        for key, value in loaded_settings.items():
+            if key in default_settings:
+                if isinstance(value, dict) and isinstance(default_settings[key], dict):
+                    self._merge_settings(default_settings[key], value)
+                else:
+                    default_settings[key] = value
+    
+    def _save_settings(self, settings=None):
+        """حفظ الإعدادات إلى ملف JSON"""
+        if settings is None:
+            settings = self.settings
+        
+        try:
+            with open(self.settings_file, "w", encoding="utf-8") as f:
+                json.dump(settings, f, ensure_ascii=False, indent=4)
+            return True
+        except Exception as e:
+            print(f"خطأ في حفظ الإعدادات: {str(e)}")
+            return False
+    
+    def get_setting(self, section, key, default=None):
+        """الحصول على قي��ة إعداد معين"""
+        try:
+            return self.settings[section][key]
+        except KeyError:
+            return default
+    
+    def set_setting(self, section, key, value):
+        """تعيين قيمة إعداد معين"""
+        if section not in self.settings:
+            self.settings[section] = {}
+        
+        self.settings[section][key] = value
+        self._save_settings()
+    
+    def get_app_name(self):
+        """الحصول على اسم التطبيق"""
+        return self.get_setting("app", "name", "نظام إدارة المناقصات")
+    
+    def get_app_version(self):
+        """الحصول على إصدار التطبيق"""
+        return self.get_setting("app", "version", "1.0.0")
+    
+    def get_language(self):
+        """الحصول على لغة التطبيق"""
+        return self.get_setting("app", "language", "ar")
+    
+    def set_language(self, language):
+        """تعيين لغة التطبيق"""
+        self.set_setting("app", "language", language)
+    
+    def get_theme(self):
+        """الحصول على نمط التطبيق"""
+        return self.get_setting("app", "theme", "light")
+    
+    def set_theme(self, theme):
+        """تعيين نمط التطبيق"""
+        self.set_setting("app", "theme", theme)
+    
+    def get_font(self):
+        """الحصول على خط التطبيق"""
+        return self.get_setting("app", "font", "Cairo")
+    
+    def set_font(self, font):
+        """تعيين خط التطبيق"""
+        self.set_setting("app", "font", font)
+    
+    def get_font_size(self):
+        """الحصول على حجم خط التطبيق"""
+        return self.get_setting("app", "font_size", 12)
+    
+    def set_font_size(self, font_size):
+        """تعيين حجم خط التطبيق"""
+        self.set_setting("app", "font_size", font_size)
+    
+    def get_window_size(self):
+        """الحصول على حجم نافذة التطبيق"""
+        width = self.get_setting("ui", "window_width", 1200)
+        height = self.get_setting("ui", "window_height", 800)
+        return (width, height)
+    
+    def set_window_size(self, width, height):
+        """تعيين حجم نافذة التطبيق"""
+        self.set_setting("ui", "window_width", width)
+        self.set_setting("ui", "window_height", height)
+    
+    def get_sidebar_width(self):
+        """الحصول على عرض الشريط الجانبي"""
+        return self.get_setting("ui", "sidebar_width", 250)
+    
+    def set_sidebar_width(self, width):
+        """تعيين عرض الشريط الجانبي"""
+        self.set_setting("ui", "sidebar_width", width)
+    
+    def get_database_config(self):
+        """الحصول على إعدادات قاعدة البيانات"""
+        return self.settings.get("database", {
+            "type": "sqlite",
+            "path": self.database_file
+        })
+    
+    def get_notifications_config(self):
+        """الحصول على إعدادات الإشعارات"""
+        return self.settings.get("notifications", {
+            "enabled": True,
+            "email_enabled": True,
+            "email_server": "smtp.example.com",
+            "email_port": 587,
+            "email_username": "",
+            "email_password": ""
+        })
+    
+    def get_reports_config(self):
+        """الحصول على إعدادات التقارير"""
+        return self.settings.get("reports", {
+            "default_format": "pdf",
+            "default_path": os.path.join(self.data_dir, "reports")
+        })
+    
+    def get_backup_config(self):
+        """الحصول على إعدادات النسخ الاحتياطي"""
+        return self.settings.get("backup", {
+            "auto_backup": True,
+            "backup_frequency": "weekly",
+            "backup_path": os.path.join(self.data_dir, "backups"),
+            "max_backups": 10
+        })

database/db_connector.py

@@ -0,0 +1,323 @@
+"""
+موصل قاعدة البيانات لنظام إدارة المناقصات
+"""
+
+import os
+import sqlite3
+import logging
+
+logger = logging.getLogger('tender_system.database')
+
+class DatabaseConnector:
+    """فئة موصل قاعدة البيانات"""
+    
+    def __init__(self, config):
+        """تهيئة موصل قاعدة البيانات"""
+        self.config = config
+        self.db_config = config.get_database_config()
+        self.db_path = self.db_config.get('path')
+        self.connection = None
+        self.cursor = None
+        
+        # إنشاء قاعدة البيانات إذا لم تكن موجودة
+        self._initialize_database()
+    
+    def _initialize_database(self):
+        """تهيئة قاعدة البيانات"""
+        try:
+            # التأكد من وجود المجلد
+            os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
+            
+            # إنشاء الاتصال
+            self.connection = sqlite3.connect(self.db_path)
+            self.cursor = self.connection.cursor()
+            
+            # إنشاء الجداول إذا لم تكن موجودة
+            self._create_tables()
+            
+            # إضافة بيانات افتراضية إذا كانت قاعدة البيانات فارغة
+            self._add_default_data()
+            
+            logger.info(f"تم تهيئة قاعدة البيانات بنجاح: {self.db_path}")
+        except Exception as e:
+            logger.error(f"خطأ في تهيئة قاعدة البيانات: {str(e)}")
+            raise
+    
+    def _create_tables(self):
+        """إنشاء جداول قاعدة البيانات"""
+        # جدول المستخدمين
+        self.cursor.execute('''
+        CREATE TABLE IF NOT EXISTS users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT UNIQUE NOT NULL,
+            password TEXT NOT NULL,
+            full_name TEXT NOT NULL,
+            email TEXT UNIQUE NOT NULL,
+            role TEXT NOT NULL,
+            status TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+        ''')
+        
+        # جدول المشاريع
+        self.cursor.execute('''
+        CREATE TABLE IF NOT EXISTS projects (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            client TEXT NOT NULL,
+            description TEXT,
+            start_date TEXT,
+            end_date TEXT,
+            status TEXT NOT NULL,
+            created_by INTEGER,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (created_by) REFERENCES users (id)
+        )
+        ''')
+        
+        # جدول المستندات
+        self.cursor.execute('''
+        CREATE TABLE IF NOT EXISTS documents (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            project_id INTEGER,
+            name TEXT NOT NULL,
+            file_path TEXT NOT NULL,
+            document_type TEXT NOT NULL,
+            description TEXT,
+            uploaded_by INTEGER,
+            uploaded_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (project_id) REFERENCES projects (id),
+            FOREIGN KEY (uploaded_by) REFERENCES users (id)
+        )
+        ''')
+        
+        # جدول بنود التسعير
+        self.cursor.execute('''
+        CREATE TABLE IF NOT EXISTS pricing_items (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            project_id INTEGER,
+            item_number TEXT NOT NULL,
+            description TEXT NOT NULL,
+            unit TEXT NOT NULL,
+            quantity REAL NOT NULL,
+            unit_price REAL NOT NULL,
+            total_price REAL NOT NULL,
+            created_by INTEGER,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (project_id) REFERENCES projects (id),
+            FOREIGN KEY (created_by) REFERENCES users (id)
+        )
+        ''')
+        
+        # جدول الموارد البشرية
+        self.cursor.execute('''
+        CREATE TABLE IF NOT EXISTS human_resources (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            position TEXT NOT NULL,
+            daily_cost REAL NOT NULL,
+            skills TEXT,
+            status TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+        ''')
+        
+        # جدول المعدات
+        self.cursor.execute('''
+        CREATE TABLE IF NOT EXISTS equipment (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            type TEXT NOT NULL,
+            daily_cost REAL NOT NULL,
+            status TEXT NOT NULL,
+            location TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+        ''')
+        
+        # جدول المواد
+        self.cursor.execute('''
+        CREATE TABLE IF NOT EXISTS materials (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            unit TEXT NOT NULL,
+            quantity REAL NOT NULL,
+            unit_price REAL NOT NULL,
+            supplier TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+        ''')
+        
+        # جدول المخاطر
+        self.cursor.execute('''
+        CREATE TABLE IF NOT EXISTS risks (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            project_id INTEGER,
+            name TEXT NOT NULL,
+            category TEXT NOT NULL,
+            probability TEXT NOT NULL,
+            impact TEXT NOT NULL,
+            risk_level TEXT NOT NULL,
+            mitigation_strategy TEXT,
+            created_by INTEGER,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (project_id) REFERENCES projects (id),
+            FOREIGN KEY (created_by) REFERENCES users (id)
+        )
+        ''')
+        
+        # جدول التقارير
+        self.cursor.execute('''
+        CREATE TABLE IF NOT EXISTS reports (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            project_id INTEGER,
+            report_type TEXT NOT NULL,
+            period TEXT,
+            file_path TEXT,
+            created_by INTEGER,
+            status TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (project_id) REFERENCES projects (id),
+            FOREIGN KEY (created_by) REFERENCES users (id)
+        )
+        ''')
+        
+        # حفظ التغييرات
+        self.connection.commit()
+    
+    def _add_default_data(self):
+        """إضافة بيانات افتراضية"""
+        # التحقق من وجود مستخدمين
+        self.cursor.execute("SELECT COUNT(*) FROM users")
+        user_count = self.cursor.fetchone()[0]
+        
+        if user_count == 0:
+            # إضافة مستخدم افتراضي (admin/admin)
+            self.cursor.execute('''
+            INSERT INTO users (username, password, full_name, email, role, status)
+            VALUES (?, ?, ?, ?, ?, ?)
+            ''', ('admin', 'admin', 'مدير النظام', '[email protected]', 'مدير', 'نشط'))
+            
+            # إضافة مستخدمين إضافيين
+            self.cursor.execute('''
+            INSERT INTO users (username, password, full_name, email, role, status)
+            VALUES (?, ?, ?, ?, ?, ?)
+            ''', ('user1', 'password', 'أحمد محمد', '[email protected]', 'مستخدم', 'نشط'))
+            
+            self.cursor.execute('''
+            INSERT INTO users (username, password, full_name, email, role, status)
+            VALUES (?, ?, ?, ?, ?, ?)
+            ''', ('user2', 'password', 'سارة أحمد', '[email protected]', 'مستخدم', 'نشط'))
+            
+            # حفظ التغييرات
+            self.connection.commit()
+            
+            logger.info("تم إضافة بيانات المستخدمين الافتراضية")
+        
+        # التحقق من وجود مشاريع
+        self.cursor.execute("SELECT COUNT(*) FROM projects")
+        project_count = self.cursor.fetchone()[0]
+        
+        if project_count == 0:
+            # إضافة مشاريع افتراضية
+            self.cursor.execute('''
+            INSERT INTO projects (name, client, description, start_date, end_date, status, created_by)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            ''', ('مشروع تطوير الطريق السريع', 'وزارة النقل', 'مشروع تطوير وتوسعة الطريق السريع', '2025-01-15', '2025-12-31', 'نشط', 1))
+            
+            self.cursor.execute('''
+            INSERT INTO projects (name, client, description, start_date, end_date, status, created_by)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            ''', ('مشروع بناء المدرسة الثانوية', 'وزارة التعليم', 'مشروع بناء مدرسة ثانوية جديدة', '2025-02-01', '2025-08-30', 'نشط', 1))
+            
+            self.cursor.execute('''
+            INSERT INTO projects (name, client, description, start_date, end_date, status, created_by)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            ''', ('مشروع تجديد المستشفى', 'وزارة الصحة', 'مشروع تجديد وتطوير المستشفى', '2024-10-15', '2025-03-15', 'مكتمل', 1))
+            
+            # حفظ التغييرات
+            self.connection.commit()
+            
+            logger.info("تم إضافة بيانات المشاريع الافتراضية")
+    
+    def execute_query(self, query, params=None):
+        """تنفيذ استعلام"""
+        try:
+            if params:
+                self.cursor.execute(query, params)
+            else:
+                self.cursor.execute(query)
+            
+            self.connection.commit()
+            return self.cursor
+        except Exception as e:
+            logger.error(f"خطأ في تنفيذ الاستعلام: {str(e)}")
+            self.connection.rollback()
+            raise
+    
+    def fetch_one(self, query, params=None):
+        """جلب صف واحد"""
+        cursor = self.execute_query(query, params)
+        return cursor.fetchone()
+    
+    def fetch_all(self, query, params=None):
+        """جلب جميع الصفوف"""
+        cursor = self.execute_query(query, params)
+        return cursor.fetchall()
+    
+    def insert(self, table, data):
+        """إدراج بيانات"""
+        columns = ', '.join(data.keys())
+        placeholders = ', '.join(['?' for _ in data])
+        query = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"
+        
+        try:
+            self.cursor.execute(query, list(data.values()))
+            self.connection.commit()
+            return self.cursor.lastrowid
+        except Exception as e:
+            logger.error(f"خطأ في إدراج البيانات: {str(e)}")
+            self.connection.rollback()
+            raise
+    
+    def update(self, table, data, condition):
+        """تحديث بيانات"""
+        set_clause = ', '.join([f"{column} = ?" for column in data.keys()])
+        query = f"UPDATE {table} SET {set_clause} WHERE {condition}"
+        
+        try:
+            self.cursor.execute(query, list(data.values()))
+            self.connection.commit()
+            return self.cursor.rowcount
+        except Exception as e:
+            logger.error(f"خطأ في تحديث البيانات: {str(e)}")
+            self.connection.rollback()
+            raise
+    
+    def delete(self, table, condition):
+        """حذف بيانات"""
+        query = f"DELETE FROM {table} WHERE {condition}"
+        
+        try:
+            self.cursor.execute(query)
+            self.connection.commit()
+            return self.cursor.rowcount
+        except Exception as e:
+            logger.error(f"خطأ في حذف البيانات: {str(e)}")
+            self.connection.rollback()
+            raise
+    
+    def close(self):
+        """إغلاق الاتصال"""
+        if self.connection:
+            self.connection.close()
+            logger.info("تم إغلاق الاتصال بقاعدة البيانات")

database/models.py

@@ -0,0 +1,626 @@
+"""
+نماذج البيانات لنظام إدارة المناقصات
+"""
+
+import sqlite3
+import logging
+from datetime import datetime
+
+logger = logging.getLogger('tender_system.models')
+
+class User:
+    """نموذج المستخدم"""
+    
+    def __init__(self, id=None, username=None, password=None, full_name=None, email=None, role=None, status=None):
+        """تهيئة نموذج المستخدم"""
+        self.id = id
+        self.username = username
+        self.password = password
+        self.full_name = full_name
+        self.email = email
+        self.role = role
+        self.status = status
+        self.created_at = None
+        self.updated_at = None
+    
+    @staticmethod
+    def authenticate(username, password, db):
+        """مصادقة المستخدم"""
+        try:
+            query = "SELECT * FROM users WHERE username = ? AND password = ? AND status = 'نشط'"
+            result = db.fetch_one(query, (username, password))
+            
+            if result:
+                user = User()
+                user.id = result[0]
+                user.username = result[1]
+                user.password = result[2]
+                user.full_name = result[3]
+                user.email = result[4]
+                user.role = result[5]
+                user.status = result[6]
+                user.created_at = result[7]
+                user.updated_at = result[8]
+                
+                return user
+            
+            return None
+        except Exception as e:
+            logger.error(f"خطأ في مصادقة المستخدم: {str(e)}")
+            return None
+    
+    @staticmethod
+    def get_by_id(user_id, db):
+        """الحصول على المستخدم بواسطة المعرف"""
+        try:
+            query = "SELECT * FROM users WHERE id = ?"
+            result = db.fetch_one(query, (user_id,))
+            
+            if result:
+                user = User()
+                user.id = result[0]
+                user.username = result[1]
+                user.password = result[2]
+                user.full_name = result[3]
+                user.email = result[4]
+                user.role = result[5]
+                user.status = result[6]
+                user.created_at = result[7]
+                user.updated_at = result[8]
+                
+                return user
+            
+            return None
+        except Exception as e:
+            logger.error(f"خطأ في الحصول على المستخدم: {str(e)}")
+            return None
+    
+    @staticmethod
+    def get_all(db):
+        """الحصول على جميع المستخدمين"""
+        try:
+            query = "SELECT * FROM users"
+            results = db.fetch_all(query)
+            
+            users = []
+            for result in results:
+                user = User()
+                user.id = result[0]
+                user.username = result[1]
+                user.password = result[2]
+                user.full_name = result[3]
+                user.email = result[4]
+                user.role = result[5]
+                user.status = result[6]
+                user.created_at = result[7]
+                user.updated_at = result[8]
+                
+                users.append(user)
+            
+            return users
+        except Exception as e:
+            logger.error(f"خطأ في الحصول على المستخدمين: {str(e)}")
+            return []
+    
+    def save(self, db):
+        """حفظ المستخدم"""
+        try:
+            if self.id:
+                # تحديث مستخدم موجود
+                data = {
+                    'username': self.username,
+                    'password': self.password,
+                    'full_name': self.full_name,
+                    'email': self.email,
+                    'role': self.role,
+                    'status': self.status,
+                    'updated_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                }
+                
+                db.update('users', data, f"id = {self.id}")
+                return self.id
+            else:
+                # إنشاء مستخدم جديد
+                data = {
+                    'username': self.username,
+                    'password': self.password,
+                    'full_name': self.full_name,
+                    'email': self.email,
+                    'role': self.role,
+                    'status': self.status
+                }
+                
+                self.id = db.insert('users', data)
+                return self.id
+        except Exception as e:
+            logger.error(f"خطأ في حفظ المستخدم: {str(e)}")
+            return None
+    
+    def delete(self, db):
+        """حذف المستخدم"""
+        try:
+            if self.id:
+                db.delete('users', f"id = {self.id}")
+                return True
+            
+            return False
+        except Exception as e:
+            logger.error(f"خطأ في حذف المستخدم: {str(e)}")
+            return False
+
+
+class Project:
+    """نموذج المشروع"""
+    
+    def __init__(self, id=None, name=None, client=None, description=None, start_date=None, end_date=None, status=None, created_by=None):
+        """تهيئة نموذج المشروع"""
+        self.id = id
+        self.name = name
+        self.client = client
+        self.description = description
+        self.start_date = start_date
+        self.end_date = end_date
+        self.status = status
+        self.created_by = created_by
+        self.created_at = None
+        self.updated_at = None
+    
+    @staticmethod
+    def get_by_id(project_id, db):
+        """الحصول على المشروع بواسطة المعرف"""
+        try:
+            query = "SELECT * FROM projects WHERE id = ?"
+            result = db.fetch_one(query, (project_id,))
+            
+            if result:
+                project = Project()
+                project.id = result[0]
+                project.name = result[1]
+                project.client = result[2]
+                project.description = result[3]
+                project.start_date = result[4]
+                project.end_date = result[5]
+                project.status = result[6]
+                project.created_by = result[7]
+                project.created_at = result[8]
+                project.updated_at = result[9]
+                
+                return project
+            
+            return None
+        except Exception as e:
+            logger.error(f"خطأ في الحصول على المشروع: {str(e)}")
+            return None
+    
+    @staticmethod
+    def get_all(db):
+        """الحصول على جميع المشاريع"""
+        try:
+            query = "SELECT * FROM projects"
+            results = db.fetch_all(query)
+            
+            projects = []
+            for result in results:
+                project = Project()
+                project.id = result[0]
+                project.name = result[1]
+                project.client = result[2]
+                project.description = result[3]
+                project.start_date = result[4]
+                project.end_date = result[5]
+                project.status = result[6]
+                project.created_by = result[7]
+                project.created_at = result[8]
+                project.updated_at = result[9]
+                
+                projects.append(project)
+            
+            return projects
+        except Exception as e:
+            logger.error(f"خطأ في الحصول على المشاريع: {str(e)}")
+            return []
+    
+    def save(self, db):
+        """حفظ المشروع"""
+        try:
+            if self.id:
+                # تحديث مشروع موجود
+                data = {
+                    'name': self.name,
+                    'client': self.client,
+                    'description': self.description,
+                    'start_date': self.start_date,
+                    'end_date': self.end_date,
+                    'status': self.status,
+                    'updated_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                }
+                
+                db.update('projects', data, f"id = {self.id}")
+                return self.id
+            else:
+                # إنشاء مشروع جديد
+                data = {
+                    'name': self.name,
+                    'client': self.client,
+                    'description': self.description,
+                    'start_date': self.start_date,
+                    'end_date': self.end_date,
+                    'status': self.status,
+                    'created_by': self.created_by
+                }
+                
+                self.id = db.insert('projects', data)
+                return self.id
+        except Exception as e:
+            logger.error(f"خطأ في حفظ المشروع: {str(e)}")
+            return None
+    
+    def delete(self, db):
+        """حذف المشروع"""
+        try:
+            if self.id:
+                db.delete('projects', f"id = {self.id}")
+                return True
+            
+            return False
+        except Exception as e:
+            logger.error(f"خطأ في حذف المشروع: {str(e)}")
+            return False
+
+
+class Document:
+    """نموذج المستند"""
+    
+    def __init__(self, id=None, project_id=None, name=None, file_path=None, document_type=None, description=None, uploaded_by=None):
+        """تهيئة نموذج المستند"""
+        self.id = id
+        self.project_id = project_id
+        self.name = name
+        self.file_path = file_path
+        self.document_type = document_type
+        self.description = description
+        self.uploaded_by = uploaded_by
+        self.uploaded_at = None
+    
+    @staticmethod
+    def get_by_id(document_id, db):
+        """الحصول على المستند بواسط�� المعرف"""
+        try:
+            query = "SELECT * FROM documents WHERE id = ?"
+            result = db.fetch_one(query, (document_id,))
+            
+            if result:
+                document = Document()
+                document.id = result[0]
+                document.project_id = result[1]
+                document.name = result[2]
+                document.file_path = result[3]
+                document.document_type = result[4]
+                document.description = result[5]
+                document.uploaded_by = result[6]
+                document.uploaded_at = result[7]
+                
+                return document
+            
+            return None
+        except Exception as e:
+            logger.error(f"خطأ في الحصول على المستند: {str(e)}")
+            return None
+    
+    @staticmethod
+    def get_by_project(project_id, db):
+        """الحصول على المستندات بواسطة معرف المشروع"""
+        try:
+            query = "SELECT * FROM documents WHERE project_id = ?"
+            results = db.fetch_all(query, (project_id,))
+            
+            documents = []
+            for result in results:
+                document = Document()
+                document.id = result[0]
+                document.project_id = result[1]
+                document.name = result[2]
+                document.file_path = result[3]
+                document.document_type = result[4]
+                document.description = result[5]
+                document.uploaded_by = result[6]
+                document.uploaded_at = result[7]
+                
+                documents.append(document)
+            
+            return documents
+        except Exception as e:
+            logger.error(f"خطأ في الحصول على المستندات: {str(e)}")
+            return []
+    
+    def save(self, db):
+        """حفظ المستند"""
+        try:
+            if self.id:
+                # تحديث مستند موجود
+                data = {
+                    'project_id': self.project_id,
+                    'name': self.name,
+                    'file_path': self.file_path,
+                    'document_type': self.document_type,
+                    'description': self.description
+                }
+                
+                db.update('documents', data, f"id = {self.id}")
+                return self.id
+            else:
+                # إنشاء مستند جديد
+                data = {
+                    'project_id': self.project_id,
+                    'name': self.name,
+                    'file_path': self.file_path,
+                    'document_type': self.document_type,
+                    'description': self.description,
+                    'uploaded_by': self.uploaded_by
+                }
+                
+                self.id = db.insert('documents', data)
+                return self.id
+        except Exception as e:
+            logger.error(f"خطأ في حفظ المستند: {str(e)}")
+            return None
+    
+    def delete(self, db):
+        """حذف المستند"""
+        try:
+            if self.id:
+                db.delete('documents', f"id = {self.id}")
+                return True
+            
+            return False
+        except Exception as e:
+            logger.error(f"خطأ في حذف المستند: {str(e)}")
+            return False
+
+
+class PricingItem:
+    """نموذج بند التسعير"""
+    
+    def __init__(self, id=None, project_id=None, item_number=None, description=None, unit=None, quantity=None, unit_price=None, total_price=None, created_by=None):
+        """تهيئة نموذج بند التسعير"""
+        self.id = id
+        self.project_id = project_id
+        self.item_number = item_number
+        self.description = description
+        self.unit = unit
+        self.quantity = quantity
+        self.unit_price = unit_price
+        self.total_price = total_price
+        self.created_by = created_by
+        self.created_at = None
+        self.updated_at = None
+    
+    @staticmethod
+    def get_by_project(project_id, db):
+        """الحصول على بنود التسعير بواسطة معرف المشروع"""
+        try:
+            query = "SELECT * FROM pricing_items WHERE project_id = ?"
+            results = db.fetch_all(query, (project_id,))
+            
+            items = []
+            for result in results:
+                item = PricingItem()
+                item.id = result[0]
+                item.project_id = result[1]
+                item.item_number = result[2]
+                item.description = result[3]
+                item.unit = result[4]
+                item.quantity = result[5]
+                item.unit_price = result[6]
+                item.total_price = result[7]
+                item.created_by = result[8]
+                item.created_at = result[9]
+                item.updated_at = result[10]
+                
+                items.append(item)
+            
+            return items
+        except Exception as e:
+            logger.error(f"خطأ في الحصول على بنود التسعير: {str(e)}")
+            return []
+    
+    def save(self, db):
+        """حفظ بند التسعير"""
+        try:
+            if self.id:
+                # تحديث بند موجود
+                data = {
+                    'project_id': self.project_id,
+                    'item_number': self.item_number,
+                    'description': self.description,
+                    'unit': self.unit,
+                    'quantity': self.quantity,
+                    'unit_price': self.unit_price,
+                    'total_price': self.total_price,
+                    'updated_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                }
+                
+                db.update('pricing_items', data, f"id = {self.id}")
+                return self.id
+            else:
+                # إنشاء بند جديد
+                data = {
+                    'project_id': self.project_id,
+                    'item_number': self.item_number,
+                    'description': self.description,
+                    'unit': self.unit,
+                    'quantity': self.quantity,
+                    'unit_price': self.unit_price,
+                    'total_price': self.total_price,
+                    'created_by': self.created_by
+                }
+                
+                self.id = db.insert('pricing_items', data)
+                return self.id
+        except Exception as e:
+            logger.error(f"خطأ في حفظ بند التسعير: {str(e)}")
+            return None
+
+
+class Risk:
+    """نموذج المخاطرة"""
+    
+    def __init__(self, id=None, project_id=None, name=None, category=None, probability=None, impact=None, risk_level=None, mitigation_strategy=None, created_by=None):
+        """تهيئة نموذج المخاطرة"""
+        self.id = id
+        self.project_id = project_id
+        self.name = name
+        self.category = category
+        self.probability = probability
+        self.impact = impact
+        self.risk_level = risk_level
+        self.mitigation_strategy = mitigation_strategy
+        self.created_by = created_by
+        self.created_at = None
+        self.updated_at = None
+    
+    @staticmethod
+    def get_by_project(project_id, db):
+        """الحصول على المخاطر بواسطة معرف المشروع"""
+        try:
+            query = "SELECT * FROM risks WHERE project_id = ?"
+            results = db.fetch_all(query, (project_id,))
+            
+            risks = []
+            for result in results:
+                risk = Risk()
+                risk.id = result[0]
+                risk.project_id = result[1]
+                risk.name = result[2]
+                risk.category = result[3]
+                risk.probability = result[4]
+                risk.impact = result[5]
+                risk.risk_level = result[6]
+                risk.mitigation_strategy = result[7]
+                risk.created_by = result[8]
+                risk.created_at = result[9]
+                risk.updated_at = result[10]
+                
+                risks.append(risk)
+            
+            return risks
+        except Exception as e:
+            logger.error(f"خطأ في الحصول على المخاطر: {str(e)}")
+            return []
+    
+    def save(self, db):
+        """حفظ المخاطرة"""
+        try:
+            if self.id:
+                # تحديث مخاطرة موجودة
+                data = {
+                    'project_id': self.project_id,
+                    'name': self.name,
+                    'category': self.category,
+                    'probability': self.probability,
+                    'impact': self.impact,
+                    'risk_level': self.risk_level,
+                    'mitigation_strategy': self.mitigation_strategy,
+                    'updated_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                }
+                
+                db.update('risks', data, f"id = {self.id}")
+                return self.id
+            else:
+                # إنشاء مخاطرة جديدة
+                data = {
+                    'project_id': self.project_id,
+                    'name': self.name,
+                    'category': self.category,
+                    'probability': self.probability,
+                    'impact': self.impact,
+                    'risk_level': self.risk_level,
+                    'mitigation_strategy': self.mitigation_strategy,
+                    'created_by': self.created_by
+                }
+                
+                self.id = db.insert('risks', data)
+                return self.id
+        except Exception as e:
+            logger.error(f"خطأ في حفظ المخاطرة: {str(e)}")
+            return None
+
+
+class Report:
+    """نموذج التقرير"""
+    
+    def __init__(self, id=None, name=None, project_id=None, report_type=None, period=None, file_path=None, created_by=None, status=None):
+        """تهيئة نموذج التقرير"""
+        self.id = id
+        self.name = name
+        self.project_id = project_id
+        self.report_type = report_type
+        self.period = period
+        self.file_path = file_path
+        self.created_by = created_by
+        self.status = status
+        self.created_at = None
+        self.updated_at = None
+    
+    @staticmethod
+    def get_by_project(project_id, db):
+        """الحصول على التقارير بواسطة معرف المشروع"""
+        try:
+            query = "SELECT * FROM reports WHERE project_id = ?"
+            results = db.fetch_all(query, (project_id,))
+            
+            reports = []
+            for result in results:
+                report = Report()
+                report.id = result[0]
+                report.name = result[1]
+                report.project_id = result[2]
+                report.report_type = result[3]
+                report.period = result[4]
+                report.file_path = result[5]
+                report.created_by = result[6]
+                report.status = result[7]
+                report.created_at = result[8]
+                report.updated_at = result[9]
+                
+                reports.append(report)
+            
+            return reports
+        except Exception as e:
+            logger.error(f"خطأ في الحصول على التقارير: {str(e)}")
+            return []
+    
+    def save(self, db):
+        """حفظ التقرير"""
+        try:
+            if self.id:
+                # تحديث تقرير موجود
+                data = {
+                    'name': self.name,
+                    'project_id': self.project_id,
+                    'report_type': self.report_type,
+                    'period': self.period,
+                    'file_path': self.file_path,
+                    'status': self.status,
+                    'updated_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                }
+                
+                db.update('reports', data, f"id = {self.id}")
+                return self.id
+            else:
+                # إنشاء تقرير جديد
+                data = {
+                    'name': self.name,
+                    'project_id': self.project_id,
+                    'report_type': self.report_type,
+                    'period': self.period,
+                    'file_path': self.file_path,
+                    'created_by': self.created_by,
+                    'status': self.status
+                }
+                
+                self.id = db.insert('reports', data)
+                return self.id
+        except Exception as e:
+            logger.error(f"خطأ في حفظ التقرير: {str(e)}")
+            return None

docs/architecture.md

@@ -0,0 +1,136 @@
+# هيكلية النظام المحسنة لنظام إدارة المناقصات
+
+## نظرة عامة
+هذا المستند يوضح هيكلية النظام المحسنة لنظام إدارة المناقصات، والذي يتضمن الوحدات التالية:
+- وحدة التسعير المتكاملة
+- وحدة الذكاء الاصطناعي
+- وحدة تحليل البيانات
+- وحدة الموارد
+
+## هيكلية المجلدات
+
+```
+tender_system/
+├── app.py                      # نقطة الدخول الرئيسية للتطبيق
+├── config.py                   # إعدادات التطبيق
+├── requirements.txt            # متطلبات المكتبات
+├── README.md                   # توثيق النظام
+├── assets/                     # الأصول الثابتة
+│   ├── images/                 # الصور
+│   ├── icons/                  # الأيقونات
+│   └── fonts/                  # الخطوط
+├── data/                       # البيانات
+│   ├── templates/              # قوالب البيانات
+│   └── charts/                 # بيانات الرسوم البيانية
+├── database/                   # قاعدة البيانات
+│   ├── db_connector.py         # موصل قاعدة البيانات
+│   └── models.py               # نماذج البيانات
+├── modules/                    # وحدات النظام
+│   ├── pricing/                # وحدة التسعير
+│   │   ├── pricing_app.py      # تطبيق التسعير
+│   │   └── services/           # خدمات التسعير
+│   │       ├── standard_pricing.py
+│   │       ├── unbalanced_pricing.py
+│   │       ├── local_content_calculator.py
+│   │       ├── price_prediction.py
+│   │       ├── construction_cost_calculator.py
+│   │       └── construction_templates.py
+│   ├── ai_assistant/           # وحدة الذكاء الاصطناعي
+│   │   ├── ai_app.py           # تطبيق الذكاء الاصطناعي
+│   │   └── services/           # خدمات الذكاء الاصطناعي
+│   │       ├── openai_service.py
+│   │       ├── anthropic_service.py
+│   │       ├── local_llm_service.py
+│   │       └── prompt_templates.py
+│   ├── document_analysis/      # وحدة تحليل المستندات
+│   │   ├── document_app.py     # تطبيق تحليل المستندات
+│   │   └── services/           # خدمات تحليل المستندات
+│   │       ├── text_extractor.py
+│   │       ├── item_extractor.py
+│   │       └── document_parser.py
+│   ├── resources/              # وحدة الموارد
+│   │   ├── resources_app.py    # تطبيق الموارد
+│   │   └── services/           # خدمات الموارد
+│   │       ├── material_manager.py
+│   │       ├── labor_manager.py
+│   │       ├── equipment_manager.py
+│   │       └── subcontractor_manager.py
+│   ├── project_management/     # وحدة إدارة المشاريع
+│   │   └── project_app.py      # تطبيق إدارة المشاريع
+│   └── reports/                # وحدة التقارير
+│       └── reports_app.py      # تطبيق التقارير
+├── styling/                    # التنسيق
+│   ├── theme.py                # سمات التطبيق
+│   ├── icons.py                # أيقونات التطبيق
+│   └── charts.py               # تنسيق الرسوم البيانية
+├── utils/                      # أدوات مساعدة
+│   ├── excel_handler.py        # معالج ملفات Excel
+│   ├── pdf_handler.py          # معالج ملفات PDF
+│   ├── helpers.py              # دوال مساعدة
+│   └── auth.py                 # المصادقة
+└── tests/                      # اختبارات
+    ├── test_pricing.py         # اختبارات وحدة التسعير
+    ├── test_ai.py              # اختبارات وحدة الذكاء الاصطناعي
+    ├── test_document.py        # اختبارات وحدة تحليل المستندات
+    └── test_resources.py       # اختبارات وحدة الموارد
+```
+
+## تفاصيل الوحدات
+
+### 1. وحدة التسعير المتكاملة
+- **الوظائف الرئيسية**:
+  - إنشاء تسعير جديد
+  - تحليل سعر البند
+  - نموذج التسعير الشامل
+  - التسعير غير المتزن
+  - المحتوى المحلي
+  - حاسبة تكاليف البناء
+  - الأدوات المساعدة
+
+### 2. وحدة الذكاء الاصطناعي
+- **الوظائف ال��ئيسية**:
+  - تحليل المستندات باستخدام الذكاء الاصطناعي
+  - توليد توصيات ذكية للتسعير
+  - تحليل المخاطر باستخدام الذكاء الاصطناعي
+  - مساعد المحادثة الذكي
+  - تلخيص المستندات
+  - استخراج المعلومات الرئيسية
+
+### 3. وحدة تحليل البيانات
+- **الوظائف الرئيسية**:
+  - استخراج النصوص من المستندات
+  - استخراج الجداول والبنود
+  - تحليل المستندات
+  - تحويل المستندات إلى بيانات منظمة
+  - تحليل الصور والمخططات
+
+### 4. وحدة الموارد
+- **الوظائف الرئيسية**:
+  - إدارة المواد
+  - إدارة العمالة
+  - إدارة المعدات
+  - إدارة المقاولين من الباطن
+  - تحليل تكاليف الموارد
+  - تخطيط الموارد
+
+## واجهة المستخدم
+- تستخدم إطار عمل Streamlit لبناء واجهة مستخدم تفاعلية
+- تدعم اللغة العربية بشكل كامل
+- تتضمن تبويبات لكل وحدة من وحدات النظام
+- تدعم الوضعين الفاتح والداكن
+- تتضمن رسومات بيانية تفاعلية باستخدام Plotly
+
+## تكامل الوحدات
+- تتكامل وحدة التسعير مع وحدة الموارد لاستخدام بيانات الأسعار
+- تتكامل وحدة تحليل البيانات مع وحدة التسعير لاستخراج بنود المناقصة
+- تتكامل وحدة الذكاء الاصطناعي مع جميع الوحدات لتقديم توصيات ذكية
+- تتكامل جميع الوحدات مع قاعدة البيانات المركزية
+
+## التقنيات المستخدمة
+- **لغة البرمجة**: Python
+- **إطار عمل واجهة المستخدم**: Streamlit
+- **معالجة البيانات**: Pandas, NumPy
+- **الرسوم البيانية**: Plotly, Matplotlib
+- **الذكاء الاصطناعي**: OpenAI API, Anthropic API, Transformers
+- **معالجة المستندات**: PyPDF2, python-docx, pdf2image
+- **قاعدة البيانات**: SQLAlchemy

docs/missing_modules_analysis.md

@@ -0,0 +1,88 @@
+# تحليل الوحدات الناقصة والميزات المطلوبة
+
+## الوحدات الناقصة في النظام الحالي
+
+بناءً على تحليل دليل المستخدم والمتطلبات المقدمة، تم تحديد الوحدات والميزات التالية التي يجب إضافتها أو تحسينها في النظام:
+
+### 1. وحدة الخرائط والمواقع
+- خرائط تفاعلية لمواقع المشاريع
+- عرض المشاريع على الخريطة بناءً على الموقع الجغرافي
+- إمكانية تحديد المسافات والمناطق
+
+### 2. وحدة الإشعارات الذكية
+- نظام إشعارات متكامل للتنبيهات المهمة
+- إشعارات للمواعيد النهائية والمهام
+- إشعارات لتغييرات حالة المناقصات والمشاريع
+
+### 3. وحدة مقارنة المستندات
+- أدوات متطورة لمقارنة المستندات
+- تحديد الاختلافات بين إصدارات المستندات
+- تحليل التغييرات في الشروط والبنود
+
+### 4. وحدة الترجمة
+- ترجمة المستندات والنصوص بين اللغات
+- دعم خاص للترجمة بين العربية والإنجليزية
+- ترجمة المصطلحات الفنية والقانونية
+
+### 5. تحسين وحدة الذكاء الاصطناعي
+- تكامل مع نماذج الذكاء الاصطناعي المتقدمة
+- العمل في بيئة هجينة (محلية وسحابية)
+- طلب مفاتيح API من قسم الأمان
+
+### 6. تحسين وحدة التسعير المتكامل
+- تطوير نظام تسعير شامل ومتكامل
+- تحسين واجهة المستخدم وسهولة الاستخدام
+- إضافة ميزات تحليل الأسعار المتقدمة
+
+### 7. تحسين وحدة إدارة المشاريع
+- تطوير وحدة متكاملة لإدارة المشاريع المرساة
+- متابعة تنفيذ المشاريع ومراحلها
+- إدارة الموارد والجداول الزمنية للمشاريع
+
+## تحسينات الواجهة المرئية المطلوبة
+
+### 1. تحسين التصميم العام
+- تطوير واجهة مستخدم أكثر احترافية
+- تحسين الألوان والتباين
+- تنسيق متناسق بين جميع الوحدات
+
+### 2. تحسين القوائم والتنقل
+- تطوير شريط قوائم رئيسي متكامل
+- تحسين تجربة التنقل بين الوحدات
+- إضافة اختصارات للوظائف الأكثر استخداماً
+
+### 3. تحسين عرض الشعار والهوية
+- تحسين عرض شعار الشركة
+- تطبيق هوية بصرية موحدة في جميع أجزاء النظام
+- إضافة خيارات تخصيص الواجهة
+
+### 4. تحسين لوحات المعلومات
+- تطوير لوحات معلومات تفاعلية وجذابة
+- تحسين عرض المؤشرات والإحصائيات
+- إضافة رسوم بيانية متقدمة
+
+## متطلبات التكامل والاتساق
+
+### 1. تكامل الوحدات
+- ضمان التكامل السلس بين جميع وحدات النظام
+- مشاركة البيانات بين الوحدات المختلفة
+- واجهة مستخدم موحدة عبر جميع الوحدات
+
+### 2. اتساق البيانات
+- ضمان اتساق البيانات بين جميع أجزاء النظام
+- تزامن البيانات بين الوحدات المختلفة
+- منع تكرار البيانات وتضاربها
+
+### 3. أداء النظام
+- تحسين سرعة استجابة النظام
+- تحسين كفاءة استخدام الموارد
+- تحسين تجربة المستخدم العامة
+
+## الاعتماديات والمتطلبات الفنية
+
+يجب تحديث ملف المتطلبات ليشمل جميع المكتبات اللازمة للوحدات الجديدة والمحسنة، بما في ذلك:
+- مكتبات الخرائط والتحليل المكاني
+- مكتبات الترجمة ومعالجة اللغات
+- مكتبات الذكاء الاصطناعي والتعلم الآلي
+- مكتبات الرسوم البيانية والتصور
+- مكتبات واجهة المستخدم المتقدمة

docs/pricing_module_design.md

@@ -0,0 +1,714 @@
+# تصميم وحدة التسعير المتكاملة وتحليل الأسعار
+
+## هيكل قاعدة البيانات
+
+### جدول فئات البنود (pricing_categories)
+```sql
+CREATE TABLE pricing_categories (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    description TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+### جدول وحدات القياس (measurement_units)
+```sql
+CREATE TABLE measurement_units (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    symbol TEXT NOT NULL,
+    description TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+### جدول بنود التسعير الأساسية (pricing_items_base)
+```sql
+CREATE TABLE pricing_items_base (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    code TEXT NOT NULL,
+    name TEXT NOT NULL,
+    description TEXT,
+    category_id INTEGER,
+    unit_id INTEGER,
+    base_price REAL NOT NULL,
+    last_updated_date TEXT,
+    price_source TEXT,
+    notes TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (category_id) REFERENCES pricing_categories (id),
+    FOREIGN KEY (unit_id) REFERENCES measurement_units (id)
+);
+```
+
+### جدول تاريخ أسعار البنود (pricing_items_history)
+```sql
+CREATE TABLE pricing_items_history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    base_item_id INTEGER,
+    price REAL NOT NULL,
+    price_date TEXT NOT NULL,
+    price_source TEXT,
+    notes TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (base_item_id) REFERENCES pricing_items_base (id)
+);
+```
+
+### جدول بنود التسعير للمشاريع (project_pricing_items)
+```sql
+CREATE TABLE project_pricing_items (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    project_id INTEGER,
+    base_item_id INTEGER,
+    item_number TEXT NOT NULL,
+    description TEXT NOT NULL,
+    unit_id INTEGER,
+    quantity REAL NOT NULL,
+    unit_price REAL NOT NULL,
+    total_price REAL NOT NULL,
+    direct_cost REAL,
+    indirect_cost REAL,
+    profit_margin REAL,
+    risk_factor REAL,
+    notes TEXT,
+    created_by INTEGER,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (project_id) REFERENCES projects (id),
+    FOREIGN KEY (base_item_id) REFERENCES pricing_items_base (id),
+    FOREIGN KEY (unit_id) REFERENCES measurement_units (id),
+    FOREIGN KEY (created_by) REFERENCES users (id)
+);
+```
+
+### جدول مكونات بنود التسعير (pricing_item_components)
+```sql
+CREATE TABLE pricing_item_components (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    pricing_item_id INTEGER,
+    component_type TEXT NOT NULL, -- 'material', 'labor', 'equipment', 'subcontractor', 'other'
+    component_name TEXT NOT NULL,
+    unit_id INTEGER,
+    quantity REAL NOT NULL,
+    unit_price REAL NOT NULL,
+    total_price REAL NOT NULL,
+    notes TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (pricing_item_id) REFERENCES project_pricing_items (id),
+    FOREIGN KEY (unit_id) REFERENCES measurement_units (id)
+);
+```
+
+### جدول عوامل التعديل (adjustment_factors)
+```sql
+CREATE TABLE adjustment_factors (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    description TEXT,
+    factor_type TEXT NOT NULL, -- 'inflation', 'location', 'risk', 'market', 'other'
+    value REAL NOT NULL,
+    start_date TEXT,
+    end_date TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+### جدول نماذج التسعير (pricing_templates)
+```sql
+CREATE TABLE pricing_templates (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    description TEXT,
+    created_by INTEGER,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (created_by) REFERENCES users (id)
+);
+```
+
+### جدول بنود نماذج التسعير (pricing_template_items)
+```sql
+CREATE TABLE pricing_template_items (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    template_id INTEGER,
+    base_item_id INTEGER,
+    item_number TEXT NOT NULL,
+    description TEXT NOT NULL,
+    unit_id INTEGER,
+    unit_price REAL NOT NULL,
+    notes TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (template_id) REFERENCES pricing_templates (id),
+    FOREIGN KEY (base_item_id) REFERENCES pricing_items_base (id),
+    FOREIGN KEY (unit_id) REFERENCES measurement_units (id)
+);
+```
+
+### جدول تنبؤات الأسعار (price_forecasts)
+```sql
+CREATE TABLE price_forecasts (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    base_item_id INTEGER,
+    forecast_date TEXT NOT NULL,
+    forecast_price REAL NOT NULL,
+    forecast_model TEXT,
+    confidence_level REAL,
+    scenario TEXT, -- 'optimistic', 'baseline', 'pessimistic'
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (base_item_id) REFERENCES pricing_items_base (id)
+);
+```
+
+## هيكل الكلاسات
+
+### 1. مدير التسعير (PricingManager)
+```python
+class PricingManager:
+    """فئة مدير التسعير الرئيسية"""
+    
+    def __init__(self, db_connector, config):
+        """تهيئة مدير التسعير"""
+        self.db = db_connector
+        self.config = config
+        self.item_manager = PricingItemManager(db_connector)
+        self.cost_calculator = CostCalculator(db_connector)
+        self.price_analyzer = PriceAnalyzer(db_connector)
+        self.price_forecaster = PriceForecaster(db_connector)
+        self.report_generator = PricingReportGenerator(db_connector)
+    
+    def initialize_database(self):
+        """تهيئة قاعدة البيانات للتسعير"""
+        # إنشاء الجداول إذا لم تكن موجودة
+        pass
+    
+    def load_default_data(self):
+        """تحميل البيانات الافتراضية"""
+        # تحميل الفئات ووحدات القياس الافتراضية
+        pass
+    
+    def get_project_pricing_summary(self, project_id):
+        """الحصول على ملخص التسعير للمشروع"""
+        pass
+    
+    def import_pricing_data(self, file_path, import_type):
+        """استيراد بيانات التسعير من ملف خارجي"""
+        pass
+    
+    def export_pricing_data(self, project_id, export_type, file_path):
+        """تصدير بيانات التسعير إلى ملف خارجي"""
+        pass
+```
+
+### 2. مدير بنود التسعير (PricingItemManager)
+```python
+class PricingItemManager:
+    """فئة إدارة بنود التسعير"""
+    
+    def __init__(self, db_connector):
+        """تهيئة مدير بنود التسعير"""
+        self.db = db_connector
+    
+    def get_all_base_items(self, filters=None):
+        """الحصول على جميع البنود الأساسية"""
+        pass
+    
+    def get_base_item_by_id(self, item_id):
+        """الحصول على بند أساسي بواسطة المعرف"""
+        pass
+    
+    def add_base_item(self, item_data):
+        """إضافة بند أساسي جديد"""
+        pass
+    
+    def update_base_item(self, item_id, item_data):
+        """تحديث بند أساسي"""
+        pass
+    
+    def delete_base_item(self, item_id):
+        """حذف بند أساسي"""
+        pass
+    
+    def get_project_items(self, project_id):
+        """الحصول على بنود المشروع"""
+        pass
+    
+    def add_project_item(self, project_id, item_data):
+        """إضافة بند للمشروع"""
+        pass
+    
+    def update_project_item(self, item_id, item_data):
+        """تحديث بند المشروع"""
+        pass
+    
+    def delete_project_item(self, item_id):
+        """حذف بند المشروع"""
+        pass
+    
+    def get_item_components(self, item_id):
+        """الحصول على مكونات البند"""
+        pass
+    
+    def add_item_component(self, item_id, component_data):
+        """إضافة مكون للبند"""
+        pass
+    
+    def update_item_component(self, component_id, component_data):
+        """تحديث مكون البند"""
+        pass
+    
+    def delete_item_component(self, component_id):
+        """حذف مكون البند"""
+        pass
+    
+    def get_categories(self):
+        """الحصول على فئات البنود"""
+        pass
+    
+    def get_measurement_units(self):
+        """الحصول على وحدات القياس"""
+        pass
+    
+    def get_templates(self):
+        """الحصول على نماذج التسعير"""
+        pass
+    
+    def get_template_items(self, template_id):
+        """الحصول على بنود النموذج"""
+        pass
+    
+    def apply_template_to_project(self, project_id, template_id):
+        """تطبيق نموذج على مشروع"""
+        pass
+```
+
+### 3. حاسبة التكاليف (CostCalculator)
+```python
+class CostCalculator:
+    """فئة حساب التكاليف"""
+    
+    def __init__(self, db_connector):
+        """تهيئة حاسبة التكاليف"""
+        self.db = db_connector
+    
+    def calculate_direct_costs(self, project_id):
+        """حساب التكاليف المباشرة"""
+        pass
+    
+    def calculate_indirect_costs(self, project_id, indirect_cost_percentage):
+        """حساب التكاليف غير المباشرة"""
+        pass
+    
+    def calculate_profit_margin(self, project_id, profit_percentage):
+        """حساب هامش الربح"""
+        pass
+    
+    def calculate_risk_contingency(self, project_id, risk_factors):
+        """حساب احتياطي المخاطر"""
+        pass
+    
+    def calculate_taxes_and_fees(self, project_id, tax_rates):
+        """حساب الضرائب والرسوم"""
+        pass
+    
+    def calculate_total_cost(self, project_id):
+        """حساب التكلفة الإجمالية"""
+        pass
+    
+    def calculate_unit_rates(self, project_id):
+        """حساب معدلات الوحدات"""
+        pass
+    
+    def apply_adjustment_factors(self, project_id, factors):
+        """تطبيق عوامل التعديل"""
+        pass
+    
+    def calculate_cost_breakdown(self, project_id):
+        """حساب تفصيل التكاليف"""
+        pass
+```
+
+### 4. محلل الأسعار (PriceAnalyzer)
+```python
+class PriceAnalyzer:
+    """فئة تحليل الأسعار"""
+    
+    def __init__(self, db_connector):
+        """تهيئة محلل الأسعار"""
+        self.db = db_connector
+    
+    def get_price_history(self, item_id):
+        """الحصول على تاريخ الأسعار"""
+        pass
+    
+    def analyze_price_trends(self, item_id, start_date, end_date):
+        """تحليل اتجاهات الأسعار"""
+        pass
+    
+    def compare_prices(self, items, date=None):
+        """مقارنة الأسعار"""
+        pass
+    
+    def calculate_price_volatility(self, item_id, period):
+        """حساب تقلب الأسعار"""
+        pass
+    
+    def perform_sensitivity_analysis(self, project_id, variable_items, ranges):
+        """إجراء تحليل الحساسية"""
+        pass
+    
+    def analyze_price_correlations(self, items):
+        """تحليل ارتباطات الأسعار"""
+        pass
+    
+    def compare_with_market_prices(self, items):
+        """مقارنة مع أسعار السوق"""
+        pass
+    
+    def analyze_cost_drivers(self, project_id):
+        """تحليل محركات التكلفة"""
+        pass
+    
+    def generate_price_analysis_charts(self, analysis_type, params):
+        """إنشاء رسوم بيانية لتحليل الأسعار"""
+        pass
+```
+
+### 5. متنبئ الأسعار (PriceForecaster)
+```python
+class PriceForecaster:
+    """فئة التنبؤ بالأسعار"""
+    
+    def __init__(self, db_connector):
+        """تهيئة متنبئ الأسعار"""
+        self.db = db_connector
+    
+    def forecast_price(self, item_id, forecast_date, model_type='arima'):
+        """التنبؤ بالسعر"""
+        pass
+    
+    def generate_price_scenarios(self, item_id, forecast_date):
+        """إنشاء سيناريوهات الأسعار"""
+        pass
+    
+    def calculate_inflation_impact(self, project_id, inflation_rate, duration):
+        """حساب تأثير التضخم"""
+        pass
+    
+    def forecast_project_costs(self, project_id, forecast_date):
+        """التنبؤ بتكاليف المشروع"""
+        pass
+    
+    def evaluate_forecast_accuracy(self, item_id):
+        """تقييم دقة التنبؤ"""
+        pass
+    
+    def generate_forecast_charts(self, item_id, forecast_date):
+        """إنشاء رسوم بيانية للتنبؤ"""
+        pass
+```
+
+### 6. مولد تقارير التسعير (PricingReportGenerator)
+```python
+class PricingReportGenerator:
+    """فئة إنشاء تقارير التسعير"""
+    
+    def __init__(self, db_connector):
+        """تهيئة مولد تقارير التسعير"""
+        self.db = db_connector
+    
+    def generate_cost_summary_report(self, project_id):
+        """إنشاء تقرير ملخص التكاليف"""
+        pass
+    
+    def generate_detailed_items_report(self, project_id):
+        """إنشاء تقرير تفصيلي للبنود"""
+        pass
+    
+    def generate_price_comparison_report(self, items, parameters):
+        """إنشاء تقرير مقارنة الأسعار"""
+        pass
+    
+    def generate_sensitivity_analysis_report(self, project_id, parameters):
+        """إنشاء تقرير تحليل الحساسية"""
+        pass
+    
+    def generate_price_forecast_report(self, items, forecast_date):
+        """إنشاء تقرير التنبؤ بالأسعار"""
+        pass
+    
+    def generate_price_risk_report(self, project_id):
+        """إنشاء تقرير مخاطر الأسعار"""
+        pass
+    
+    def export_report_to_pdf(self, report_data, file_path):
+        """تصدير التقرير إلى PDF"""
+        pass
+    
+    def export_report_to_excel(self, report_data, file_path):
+        """تصدير التقرير إلى Excel"""
+        pass
+```
+
+## تصميم واجهة المستخدم
+
+### 1. الشاشة الرئيسية لوحدة التسعير
+
+```
++--------------------------------------------------+
+|                  وحدة التسعير                    |
++--------------------------------------------------+
+|                                                  |
+|  +----------------+  +----------------------+    |
+|  | المناقصات      |  | إحصائيات التسعير     |    |
+|  | الحالية        |  |                      |    |
+|  |                |  |                      |    |
+|  |                |  |                      |    |
+|  |                |  |                      |    |
+|  +----------------+  +----------------------+    |
+|                                                  |
+|  +----------------+  +----------------------+    |
+|  | الوصول         |  | آخر التحديثات        |    |
+|  | السريع         |  |                      |    |
+|  |                |  |                      |    |
+|  |                |  |                      |    |
+|  |                |  |                      |    |
+|  +----------------+  +----------------------+    |
+|                                                  |
++--------------------------------------------------+
+```
+
+### 2. شاشة إدارة بنود التسعير
+
+```
++--------------------------------------------------+
+|                إدارة بنود التسعير                |
++--------------------------------------------------+
+| بحث: [                    ] [تصفية▼] [تصدير]     |
++--------------------------------------------------+
+| # | الكود | الوصف | الوحدة | الكمية | السعر | المجموع |
++--------------------------------------------------+
+| 1 |       |       |        |        |      |        |
+| 2 |       |       |        |        |      |        |
+| 3 |       |       |        |        |      |        |
+| 4 |       |       |        |        |      |        |
+| 5 |       |       |        |        |      |        |
++--------------------------------------------------+
+| [إضافة بند] [حذف المحدد] [استيراد من Excel]      |
++--------------------------------------------------+
+| المجموع الكلي:                                   |
++--------------------------------------------------+
+```
+
+### 3. شاشة تفاصيل البند
+
+```
++--------------------------------------------------+
+|                  تفاصيل البند                    |
++--------------------------------------------------+
+| الكود: [        ]  الوصف: [                    ] |
+| الفئة: [        ▼] الوحدة: [                  ▼] |
++--------------------------------------------------+
+| مكونات البند:                                    |
++--------------------------------------------------+
+| النوع | الوصف | الوحدة | الكمية | السعر | المجموع |
++--------------------------------------------------+
+| مواد |      |        |        |      |        |
+| عمالة |      |        |        |      |        |
+| معدات |      |        |        |      |        |
+| أخرى |      |        |        |      |        |
++--------------------------------------------------+
+| [إضافة مكون] [حذف المحدد]                        |
++--------------------------------------------------+
+| التكلفة المباشرة:                                |
+| التكلفة غير المباشرة:                            |
+| هامش الربح:                                      |
+| احتياطي المخاطر:                                 |
+| السعر النهائي:                                   |
++--------------------------------------------------+
+| [حفظ] [إلغاء]                                    |
++--------------------------------------------------+
+```
+
+### 4. شاشة تحليل الأسعار
+
+```
++--------------------------------------------------+
+|                 تحليل الأسعار                    |
++--------------------------------------------------+
+| [اختيار البند▼] [الفترة الزمنية▼] [تحليل]       |
++--------------------------------------------------+
+|                                                  |
+|                                                  |
+|                                                  |
+|              (رسم بياني للأسعار)                 |
+|                                                  |
+|                                                  |
+|                                                  |
++--------------------------------------------------+
+| إحصائيات:                                        |
+| - متوسط السعر:                                   |
+| - أعلى سعر:                                      |
+| - أدنى سعر:                                      |
+| - معدل التغير:                                   |
+| - التقلب:                                        |
++--------------------------------------------------+
+| [مقارنة مع بنود أخرى] [تصدير التحليل]            |
++--------------------------------------------------+
+```
+
+### 5. ش��شة التنبؤ بالأسعار
+
+```
++--------------------------------------------------+
+|                التنبؤ بالأسعار                   |
++--------------------------------------------------+
+| [اختيار البند▼] [تاريخ التنبؤ] [نموذج التنبؤ▼]   |
++--------------------------------------------------+
+|                                                  |
+|                                                  |
+|                                                  |
+|            (رسم بياني للتنبؤ بالأسعار)           |
+|                                                  |
+|                                                  |
+|                                                  |
++--------------------------------------------------+
+| السيناريوهات:                                    |
+| - متفائل:                                        |
+| - متوسط:                                         |
+| - متشائم:                                        |
++--------------------------------------------------+
+| عوامل التأثير:                                   |
+| - التضخم:                                        |
+| - تغيرات السوق:                                  |
+| - العوامل الموسمية:                              |
++--------------------------------------------------+
+| [تطبيق على المشروع] [تصدير التنبؤ]               |
++--------------------------------------------------+
+```
+
+### 6. شاشة تحليل الحساسية
+
+```
++--------------------------------------------------+
+|                تحليل الحساسية                    |
++--------------------------------------------------+
+| المشروع: [                                     ▼] |
++--------------------------------------------------+
+| المتغيرات:                                       |
+| [✓] أسعار المواد الخام (±20%)                    |
+| [✓] تكلفة العمالة (±15%)                         |
+| [✓] تكلفة المعدات (±10%)                         |
+| [ ] المصاريف العامة (±5%)                        |
++--------------------------------------------------+
+|                                                  |
+|                                                  |
+|            (رسم بياني لتحليل الحساسية)           |
+|                                                  |
+|                                                  |
+|                                                  |
++--------------------------------------------------+
+| النتائج:                                         |
+| - أكثر العوامل تأثيراً:                          |
+| - نطاق التغير المتوقع:                           |
+| - توصيات:                                        |
++--------------------------------------------------+
+| [تحديث التحليل] [تصدير النتائج]                  |
++--------------------------------------------------+
+```
+
+### 7. شاشة التقارير
+
+```
++--------------------------------------------------+
+|                   التقارير                       |
++--------------------------------------------------+
+| [نوع التقرير▼] [المشروع▼] [إنشاء تقرير]          |
++--------------------------------------------------+
+| التقارير المتاحة:                                |
+|                                                  |
+| ○ ملخص التكاليف                                  |
+| ○ تفصيل البنود                                   |
+| ○ مقارنة الأسعار                                 |
+| ○ تحليل الحساسية                                 |
+| ○ التنبؤ بالأسعار                                |
+| ○ مخاطر الأسعار                                  |
+|                                                  |
++--------------------------------------------------+
+| خيارات التقرير:                                  |
+|                                                  |
+| [✓] تضمين الرسوم البيانية                        |
+| [✓] تضمين التوصيات                               |
+| [ ] تضمين البيانات التفصيلية                     |
+|                                                  |
++--------------------------------------------------+
+| [PDF] [Excel] [طباعة]                            |
++--------------------------------------------------+
+```
+
+## تكامل النظام
+
+### 1. تكامل مع وحدة تحليل المستندات
+- استخراج بنود التسعير من وثائق المناقصة
+- تحديد الكميات والمواصفات من المستندات
+- مقارنة البنود المستخرجة مع قاعدة البيانات
+
+### 2. تكامل مع وحدة تحليل المخاطر
+- ��حديد المخاطر المرتبطة بالتسعير
+- تقييم تأثير المخاطر على التكاليف
+- تحديد احتياطي المخاطر المناسب
+
+### 3. تكامل مع وحدة إدارة المشاريع
+- متابعة التكاليف الفعلية مقابل المخططة
+- تحديث التنبؤات بناءً على بيانات المشروع الفعلية
+- تحليل انحرافات التكاليف
+
+### 4. تكامل مع وحدة التقارير
+- إنشاء تقارير متكاملة تشمل بيانات التسعير
+- دمج تحليلات التسعير في تقارير المشروع
+- توفير لوحات معلومات متكاملة
+
+## خطة التنفيذ التفصيلية
+
+### المرحلة 1: إعداد البنية التحتية (3 أيام)
+- تصميم وإنشاء جداول قاعدة البيانات
+- إعداد هيكل الملفات والمجلدات
+- تهيئة البيئة التطويرية
+
+### المرحلة 2: تنفيذ الوظائف الأساسية (5 أيام)
+- تنفيذ فئة مدير التسعير
+- تنفيذ فئة مدير بنود التسعير
+- تنفيذ فئة حاسبة التكاليف
+- إنشاء واجهات المستخدم الأساسية
+
+### المرحلة 3: تنفيذ وظائف التحليل (7 أيام)
+- تنفيذ فئة محلل الأسعار
+- تنفيذ فئة متنبئ الأسعار
+- إنشاء الرسوم البيانية والتحليلات
+- تنفيذ واجهات المستخدم للتحليل
+
+### المرحلة 4: تنفيذ التقارير والتكامل (5 أيام)
+- تنفيذ فئة مولد تقارير التسعير
+- تكامل مع الوحدات الأخرى
+- إنشاء واجهات المستخدم للتقارير
+- اختبار التكامل
+
+### المرحلة 5: الاختبار والتحسين (3 أيام)
+- اختبار جميع الوظائف
+- تحسين الأداء
+- إصلاح الأخطاء
+- تحسين واجهة المستخدم
+
+### المرحلة 6: التوثيق والتسليم (2 أيام)
+- إعداد وثائق المستخدم
+- إعداد وثائق المطور
+- تجهيز النسخة النهائية
+- تسليم النظام

docs/pricing_module_requirements.md

@@ -0,0 +1,155 @@
+# متطلبات وحدة التسعير المتكاملة وتحليل الأسعار
+
+## الهدف
+تطوير وحدة متكاملة للتسعير وتحليل الأسعار في نظام إدارة المناقصات لتمكين المستخدمين من إدارة عمليات التسعير بشكل أكثر دقة وفعالية، وتوفير أدوات تحليلية متقدمة لاتخاذ قرارات أفضل.
+
+## المتطلبات الوظيفية
+
+### 1. إدارة بنود التسعير
+- إنشاء وتحرير وحذف بنود التسعير
+- تصنيف البنود حسب الفئات (مواد، عمالة، معدات، مصاريف عامة)
+- دعم الوحدات المختلفة (متر مربع، متر مكعب، عدد، طن، إلخ)
+- إمكانية استيراد بنود التسعير من ملفات Excel
+- إمكانية تصدير بنود التسعير إلى ملفات Excel
+
+### 2. حساب التكاليف
+- حساب تكلفة المواد المباشرة
+- حساب تكلفة العمالة المباشرة
+- حساب تكلفة المعدات
+- حساب المصاريف العامة والإدارية
+- حساب هامش الربح
+- حساب الضرائب والرسوم
+
+### 3. تحليل الأسعار
+- مقارنة الأسعار التاريخية للبنود
+- تحليل تغيرات الأسعار عبر الزمن
+- تحليل حساسية الأسعار للمتغيرات المختلفة
+- تحليل المخاطر المرتبطة بتغيرات الأسعار
+- مقارنة الأسعار مع أسعار السوق
+- تحليل تأثير تغير أسعار المواد الخام على التكلفة الإجمالية
+
+### 4. التنبؤ بالأسعار
+- التنبؤ بتغيرات الأسعار المستقبلية
+- حساب معدلات التضخم المتوقعة
+- تقدير تأثير العوامل الاقتصادية على الأسعار
+- إنشاء سيناريوهات مختلفة للأسعار (متفائل، متوسط، متشائم)
+
+### 5. تقارير التسعير
+- تقرير ملخص التكاليف
+- تقرير تفصيلي للبنود
+- تقرير مقارنة الأسعار
+- تقرير تحليل الحساسية
+- تقرير التنبؤ بالأسعار
+- تقرير المخاطر المرتبطة بالأسعار
+
+### 6. لوحة معلومات التسعير
+- عرض مؤشرات الأداء الرئيسية للتسعير
+- عرض الرسوم البيانية لتحليل الأسعار
+- عرض تنبيهات لتغيرات الأسعار الكبيرة
+- عرض مقارنات مع المناقصات السابقة
+
+## المتطلبات غير الوظيفية
+
+### 1. الأداء
+- سرعة استجابة عالية عند التعامل مع كميات كبيرة من البيانات
+- قدرة على معالجة آلاف البنود في المناقصة الواحدة
+
+### 2. قابلية الاستخدام
+- واجهة مستخدم بديهية وسهلة الاستخدام
+- إمكانية تخصيص العرض حسب احتياجات المستخدم
+- توفير أدوات مساعدة وشروحات للمستخدمين
+
+### 3. التكامل
+- تكامل مع وحدة تحليل المستندات لاستخراج بنود التسعير من وثائق المناقصة
+- تكامل مع وحدة تحليل المخاطر لتقييم مخاطر التسعير
+- تكامل مع وحدة إدارة المشاريع لمتابعة التكاليف الفعلية مقابل المخططة
+
+### 4. الأمان
+- تحديد صلاحيات الوصول لبيانات التسعير
+- تسجيل جميع التغييرات على بيانات التسعير
+- حماية البيانات الحساسة المتعلقة بالتسعير
+
+## التقنيات المقترحة
+
+### 1. تخزين البيانات
+- استخدام قاعدة بيانات SQLite لتخزين بيانات التسعير
+- تصميم جداول مناسبة لتخزين البنود والتكاليف والأسعار التاريخية
+
+### 2. تحليل البيانات
+- استخدام مكتبة Pandas لمعالجة وتحليل بيانات الأسعار
+- استخدام مكتبة NumPy للعمليات الحسابية المتقدمة
+- استخدام مكتبة SciPy للتحليل الإحصائي
+
+### 3. التنبؤ بالأسعار
+- استخدام مكتبة Statsmodels للنماذج الإحصائية
+- استخدام مكتبة Prophet للتنبؤ بالسلاسل الزمنية
+- استخدام مكتبة scikit-learn لنماذج التعلم الآلي
+
+### 4. العرض المرئي
+- استخدام مكتبة Matplotlib لإنشاء الرسوم البيانية الأساسية
+- استخدام مكتبة Seaborn للرسوم البيانية الإحصائية المتقدمة
+- استخدام مكتبة Plotly للرسوم البيانية التفاعلية
+
+## الواجهة المقترح��
+
+### 1. الشاشة الرئيسية لوحدة التسعير
+- قائمة بالمناقصات الحالية
+- ملخص لإحصائيات التسعير
+- الوصول السريع للوظائف الشائعة
+
+### 2. شاشة إدارة بنود التسعير
+- جدول لعرض وتحرير البنود
+- أدوات للتصفية والبحث
+- أزرار للإضافة والحذف والاستيراد والتصدير
+
+### 3. شاشة حساب التكاليف
+- نموذج لإدخال معلومات التكاليف
+- عرض ملخص للتكاليف حسب الفئات
+- حاسبة تفاعلية للتكاليف
+
+### 4. شاشة تحليل الأسعار
+- رسوم بيانية لتحليل الأسعار
+- أدوات للمقارنة والتحليل
+- خيارات لتخصيص التحليل
+
+### 5. شاشة التنبؤ بالأسعار
+- نماذج للتنبؤ بالأسعار
+- عرض السيناريوهات المختلفة
+- تحليل الحساسية للمتغيرات
+
+### 6. شاشة تقارير التسعير
+- قائمة بالتقارير المتاحة
+- خيارات لتخصيص التقارير
+- أدوات لتصدير التقارير
+
+## خطة التنفيذ
+
+### المرحلة 1: تصميم قاعدة البيانات وهيكل الوحدة
+- تصميم جداول قاعدة البيانات
+- تصميم هيكل الكلاسات والوظائف
+- تصميم واجهة المستخدم
+
+### المرحلة 2: تنفيذ إدارة بنود التسعير وحساب التكاليف
+- تنفيذ وظائف إدارة البنود
+- تنفيذ وظائف حساب التكاليف
+- تنفيذ واجهة المستخدم لهذه الوظائف
+
+### المرحلة 3: تنفيذ تحليل الأسعار والتنبؤ
+- تنفيذ وظائف تحليل الأسعار
+- تنفيذ وظائف التنبؤ بالأسعار
+- تنفيذ واجهة المستخدم لهذه الوظائف
+
+### المرحلة 4: تنفيذ التقارير ولوحة المعلومات
+- تنفيذ وظائف إنشاء التقارير
+- تنفيذ لوحة معلومات التسعير
+- تنفيذ واجهة المستخدم لهذه الوظائف
+
+### المرحلة 5: التكامل والاختبار
+- تكامل الوحدة مع النظام الحالي
+- اختبار الوظائف والأداء
+- تصحيح الأخطاء وتحسين الأداء
+
+### المرحلة 6: التوثيق والتسليم
+- توثيق الوحدة وكيفية استخدامها
+- إعداد أمثلة ودروس تعليمية
+- تسليم الوحدة للمستخدم النهائي

modules/ai_assistant/ai_app.py

@@ -0,0 +1,855 @@
+"""
+وحدة الذكاء الاصطناعي - التطبيق الرئيسي
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime
+import time
+import io
+import os
+import json
+import base64
+from pathlib import Path
+import tempfile
+from PIL import Image
+
+# استيراد محلل المستندات
+from .document_analyzer import AIDocumentAnalyzer, DocumentParser
+
+# استيراد وحدة تكامل البيانات
+from .data_integration import DataAIIntegration
+
+class AIAssistantApp:
+    """وحدة الذكاء الاصطناعي"""
+    
+    def __init__(self):
+        """تهيئة وحدة الذكاء الاصطناعي"""
+        
+        # تهيئة حالة الجلسة
+        if 'chat_history' not in st.session_state:
+            st.session_state.chat_history = [
+                {
+                    'role': 'assistant',
+                    'content': 'مرحباً! أنا مساعدك الذكي لإدارة المناقصات. كيف يمكنني مساعدتك اليوم؟'
+                }
+            ]
+        
+        if 'document_summaries' not in st.session_state:
+            st.session_state.document_summaries = [
+                {
+                    'id': 1,
+                    'title': 'كراسة الشروط والمواصفات - مشروع إنشاء مبنى إداري',
+                    'date': '2024-03-15',
+                    'summary': 'تتضمن كراسة الشروط والمواصفات لمشروع إنشاء مبنى إداري متطلبات المشروع وشروط التنفيذ والمواصفات الفنية للأعمال المطلوبة. يتكون المبنى من 5 طوابق بمساحة إجمالية 5000 متر مربع. تشمل الأعمال الأساسية: الأعمال الإنشائية، الأعمال المعمارية، الأعمال الكهربائية، الأعمال الميكانيكية، وأعمال التشطيبات.',
+                    'key_points': [
+                        'مدة التنفيذ: 18 شهراً',
+                        'قيمة الضمان الابتدائي: 2% من قيمة العطاء',
+                        'قيمة الضمان النهائي: 5% من قيمة العقد',
+                        'غرامة التأخير: 1% من قيمة العقد عن كل أسبوع تأخير بحد أقصى 10%',
+                        'شروط الدفع: دفعات شهرية حسب نسبة الإنجاز'
+                    ],
+                    'entities': {
+                        'الجهة المالكة': 'وزارة المالية',
+                        'موقع المشروع': 'الرياض - حي العليا',
+                        'رقم المناقصة': 'T-2024-001',
+                        'تاريخ الطرح': '2024-03-01',
+                        'تاريخ الإقفال': '2024-04-15'
+                    }
+                },
+                {
+                    'id': 2,
+                    'title': 'جدول الكميات - مشروع تطوير شبكة طرق',
+                    'date': '2024-03-20',
+                    'summary': 'يتضمن جدول الكميات لمشروع تطوير شبكة طرق تفاصيل الأعمال المطلوبة والكميات التقديرية. يشمل المشروع إنشاء طرق جديدة بطول 15 كم وتطوير طرق قائمة بطول 10 كم، بالإضافة إلى إنشاء 3 جسور و5 أنفاق.',
+                    'key_points': [
+                        'إجمالي أعمال الحفر: 250,000 م3',
+                        'إجمالي أعمال الردم: 180,000 م3',
+                        'إجمالي أعمال الخرسانة: 45,000 م3',
+                        'إجمالي أعمال الأسفلت: 120,000 م2',
+                        'إجمالي أعمال الإنارة: 500 عمود إنارة'
+                    ],
+                    'entities': {
+                        'الجهة المالكة': 'وزارة النقل',
+                        'موقع المشروع': 'جدة',
+                        'رقم المناقصة': 'T-2024-002',
+                        'تاريخ الطرح': '2024-03-10',
+                        'تاريخ الإقفال': '2024-04-20'
+                    }
+                },
+                {
+                    'id': 3,
+                    'title': 'المواصفات الفنية - مشروع بناء مدرسة',
+                    'date': '2024-03-25',
+                    'summary': 'تتضمن المواصفات الفنية لمشروع بناء مدرسة تفاصيل المتطلبات الفنية للمشروع. تتكون المدرسة من 3 طوابق بمساحة إجمالية 3000 متر مربع، وتشمل 20 فصلاً دراسياً، ومختبرات علوم، وقاع�� متعددة الأغراض، ومكتبة، وغرف إدارية.',
+                    'key_points': [
+                        'نوع الهيكل: خرساني مسلح',
+                        'نظام التكييف: نظام مركزي',
+                        'نظام الإنارة: LED موفر للطاقة',
+                        'نظام مكافحة الحريق: نظام رش آلي',
+                        'متطلبات خاصة: نظام طاقة شمسية لتوفير 30% من احتياجات الطاقة'
+                    ],
+                    'entities': {
+                        'الجهة المالكة': 'وزارة التعليم',
+                        'موقع المشروع': 'الدمام',
+                        'رقم المناقصة': 'T-2024-003',
+                        'تاريخ الطرح': '2024-03-15',
+                        'تاريخ الإقفال': '2024-04-25'
+                    }
+                }
+            ]
+        
+        if 'ai_models' not in st.session_state:
+            st.session_state.ai_models = [
+                {
+                    'id': 1,
+                    'name': 'نموذج تحليل المستندات',
+                    'description': 'نموذج ذكاء اصطناعي لتحليل مستندات المناقصات واستخراج المعلومات الرئيسية منها.',
+                    'type': 'معالجة اللغة الطبيعية',
+                    'accuracy': 92,
+                    'last_updated': '2024-03-01'
+                },
+                {
+                    'id': 2,
+                    'name': 'نموذج تقدير التكاليف',
+                    'description': 'نموذج ذكاء اصطناعي لتقدير تكاليف المشاريع بناءً على بيانات المشاريع السابقة.',
+                    'type': 'تعلم آلي',
+                    'accuracy': 85,
+                    'last_updated': '2024-02-15'
+                },
+                {
+                    'id': 3,
+                    'name': 'نموذج تحليل المخاطر',
+                    'description': 'نموذج ذكاء اصطناعي لتحليل المخاطر المحتملة للمشاريع وتقديم توصيات للتخفيف منها.',
+                    'type': 'تعلم آلي',
+                    'accuracy': 88,
+                    'last_updated': '2024-02-20'
+                },
+                {
+                    'id': 4,
+                    'name': 'نموذج تحليل المنافسين',
+                    'description': 'نموذج ذكاء اصطناعي لتحليل المنافسين وتقديم توصيات لزيادة فرص الفوز بالمناقصات.',
+                    'type': 'تعلم آلي',
+                    'accuracy': 80,
+                    'last_updated': '2024-02-10'
+                },
+                {
+                    'id': 5,
+                    'name': 'نموذج تحليل ملفات DWG',
+                    'description': 'نموذج ذكاء اصطناعي لتحليل ملفات DWG واستخراج المعلومات الرئيسية منها.',
+                    'type': 'رؤية حاسوبية',
+                    'accuracy': 90,
+                    'last_updated': '2024-03-10'
+                }
+            ]
+        
+        # تهيئة متغير السمة في حالة الجلسة إذا لم يكن موجوداً
+        if 'theme' not in st.session_state:
+            st.session_state.theme = 'light'
+        
+        # تهيئة محلل المستندات
+        self.document_analyzer = AIDocumentAnalyzer()
+        
+        # تهيئة وحدة تكامل البيانات
+        self.data_integration = DataAIIntegration()
+        
+        # تكامل وحدة تحليل البيانات مع وحدة الذكاء الاصطناعي
+        self.data_integration.integrate_with_ai_assistant(self)
+    
+    def run(self):
+        """
+        تشغيل وحدة الذكاء الاصطناعي
+        
+        هذه الدالة هي نقطة الدخول الرئيسية لوحدة الذكاء الاصطناعي.
+        تقوم بتهيئة واجهة المستخدم وعرض الوظائف المختلفة للذكاء الاصطناعي.
+        """
+        try:
+            # تعيين عنوان الصفحة
+            st.set_page_config(
+                page_title="وحدة الذكاء الاصطناعي - نظام المناقصات",
+                page_icon="🤖",
+                layout="wide",
+                initial_sidebar_state="expanded"
+            )
+            
+            # تطبيق التنسيق المخصص
+            st.markdown("""
+            <style>
+            .module-title {
+                color: #2c3e50;
+                text-align: center;
+                font-size: 2.5rem;
+                margin-bottom: 1rem;
+                padding-bottom: 1rem;
+                border-bottom: 2px solid #3498db;
+            }
+            .stTabs [data-baseweb="tab-list"] {
+                gap: 10px;
+            }
+            .stTabs [data-baseweb="tab"] {
+                height: 50px;
+                white-space: pre-wrap;
+                background-color: #f8f9fa;
+                border-radius: 4px 4px 0px 0px;
+                gap: 1px;
+                padding-top: 10px;
+                padding-bottom: 10px;
+            }
+            .stTabs [aria-selected="true"] {
+                background-color: #3498db;
+                color: white;
+            }
+            </style>
+            """, unsafe_allow_html=True)
+            
+            # إضافة زر تبديل السمة في أعلى الصفحة
+            col1, col2, col3 = st.columns([1, 8, 1])
+            with col3:
+                if st.button("🌓 تبديل السمة"):
+                    # تبديل السمة
+                    if st.session_state.theme == "light":
+                        st.session_state.theme = "dark"
+                    else:
+                        st.session_state.theme = "light"
+                    
+                    # تطبيق السمة الجديدة وإعادة تشغيل التطبيق
+                    st.rerun()
+            
+            # عرض الشريط الجانبي
+            with st.sidebar:
+                st.image("/home/ubuntu/tender_system/tender_system/assets/images/logo.png", width=200)
+                st.markdown("## نظام تحليل المناقصات")
+                st.markdown("### وحدة الذكاء الاصطناعي")
+                
+                st.markdown("---")
+                
+                # إضافة خيارات الذكاء الاصطناعي
+                st.markdown("### إعدادات الذكاء الاصطناعي")
+                
+                # اختيار نموذج الذكاء الاصطناعي
+                ai_model = st.selectbox(
+                    "نموذج الذكاء الاصطناعي",
+                    ["OpenAI GPT-4", "Claude 3 Opus", "Gemini Pro", "محلي"]
+                )
+                
+                # إعدادات النموذج
+                st.markdown("#### إعدادات النموذج")
+                temperature = st.slider("درجة الإبداعية", 0.0, 1.0, 0.7, 0.1)
+                max_tokens = st.slider("الحد الأقصى للكلمات", 100, 4000, 2000, 100)
+                
+                # إعدادات التكامل مع بيئة هجين فيس
+                st.markdown("#### إعدادات التكامل")
+                hybrid_face_integration = st.checkbox("تمكين التكامل مع بيئة هجين فيس", value=True)
+                
+                if hybrid_face_integration:
+                    api_key_source = st.radio(
+                        "مصدر مفتاح API",
+                        ["قسم الأمان", "إدخال يدوي"]
+                    )
+                    
+                    if api_key_source == "إدخال يدوي":
+                        api_key = st.text_input("مفتاح API", type="password")
+                
+                st.markdown("---")
+                
+                # إضافة معلومات المستخدم
+                st.markdown("### معلومات المستخدم")
+                st.markdown("**المستخدم:** مهندس تامر الجوهري")
+                st.markdown("**الدور:** محلل مناقصات")
+                st.markdown("**تاريخ آخر دخول:** " + datetime.now().strftime("%Y-%m-%d %H:%M"))
+            
+            # عرض واجهة وحدة الذكاء الاصطناعي
+            self.render()
+            
+            # إضافة معلومات في أسفل الصفحة
+            st.markdown("---")
+            st.markdown("### نظام تحليل المناقصات - وحدة الذكاء الاصطناعي")
+            st.markdown("**الإصدار:** 2.0.0")
+            st.markdown("**تاريخ التحديث:** 2025-03-31")
+            st.markdown("**جميع الحقوق محفوظة © 2025**")
+            
+            return True
+            
+        except Exception as e:
+            st.error(f"حدث خطأ أثناء تشغيل وحدة الذكاء الاصطناعي: {str(e)}")
+            return False
+
+    def render(self):
+        """عرض واجهة وحدة الذكاء الاصطناعي"""
+        
+        st.markdown("<h1 class='module-title'>وحدة الذكاء الاصطناعي</h1>", unsafe_allow_html=True)
+        
+        tabs = st.tabs(["المساعد الذكي", "تحليل المستندات", "تقدير التكاليف", "تحليل المخاطر", "نماذج الذكاء الاصطناعي"])
+        
+        with tabs[0]:
+            self._render_assistant_tab()
+        
+        with tabs[1]:
+            self._render_document_analysis_tab()
+        
+        with tabs[2]:
+            self._render_cost_estimation_tab()
+        
+        with tabs[3]:
+            self._render_risk_analysis_tab()
+        
+        with tabs[4]:
+            self._render_ai_models_tab()
+
+    def _render_assistant_tab(self):
+        """عرض تبويب المساعد الذكي"""
+        
+        st.markdown("### المساعد الذكي")
+        
+        # عرض محادثة المساعد الذكي
+        chat_container = st.container()
+        
+        with chat_container:
+            for message in st.session_state.chat_history:
+                if message['role'] == 'user':
+                    st.markdown(f"<div style='background-color: #f0f0f0; padding: 10px; border-radius: 10px; margin-bottom: 10px;'><strong>أنت:</strong> {message['content']}</div>", unsafe_allow_html=True)
+                else:
+                    st.markdown(f"<div style='background-color: #e1f5fe; padding: 10px; border-radius: 10px; margin-bottom: 10px;'><strong>المساعد:</strong> {message['content']}</div>", unsafe_allow_html=True)
+        
+        # إضافة حقل إدخال الرسالة
+        user_input = st.text_input("اكتب رسالتك هنا...", key="user_input")
+        
+        if st.button("إرسال"):
+            if user_input:
+                # إضافة رسالة المستخدم إلى المحادثة
+                st.session_state.chat_history.append({
+                    'role': 'user',
+                    'content': user_input
+                })
+                
+                # محاكاة استجابة المساعد الذكي
+                response = self._generate_assistant_response(user_input)
+                
+                # إضافة استجابة المساعد إلى المحادثة
+                st.session_state.chat_history.append({
+                    'role': 'assistant',
+                    'content': response
+                })
+                
+                # إعادة تشغيل التطبيق لتحديث المحادثة
+                st.rerun()
+        
+        # إضافة زر لمسح المحادثة
+        if st.button("مسح المحادثة"):
+            st.session_state.chat_history = [
+                {
+                    'role': 'assistant',
+                    'content': 'مرحباً! أنا مساعدك الذكي لإدارة المناقصات. كيف يمكنني مساعدتك اليوم؟'
+                }
+            ]
+            st.rerun()
+
+    def _render_document_analysis_tab(self):
+        """عرض تبويب تحليل المستندات"""
+        
+        st.markdown("### تحليل المستندات")
+        
+        # إضافة خيارات تحليل المستندات
+        analysis_type = st.selectbox(
+            "نوع التحليل",
+            ["تحليل كراسة الشروط", "تحليل جدول الكميات", "تحليل العقود", "تحليل ملفات DWG"]
+        )
+        
+        # رفع الملف
+        uploaded_file = st.file_uploader("رفع ملف للتحليل", type=["pdf", "docx", "xlsx", "dwg"])
+        
+        if uploaded_file is not None:
+            # عرض معلومات الملف
+            file_details = {
+                "اسم الملف": uploaded_file.name,
+                "نوع الملف": uploaded_file.type,
+                "حجم الملف": f"{uploaded_file.size / 1024:.1f} كيلوبايت"
+            }
+            
+            st.write("### معلومات الملف")
+            for key, value in file_details.items():
+                st.write(f"**{key}:** {value}")
+            
+            # حفظ الملف مؤقتاً
+            with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(uploaded_file.name)[1]) as tmp_file:
+                tmp_file.write(uploaded_file.getvalue())
+                tmp_file_path = tmp_file.name
+            
+            # تحليل الملف
+            if st.button("تحليل الملف"):
+                with st.spinner("جاري تحليل الملف..."):
+                    if analysis_type == "تحليل ملفات DWG":
+                        # استخدام وحدة تكامل البيانات لتحليل ملف DWG
+                        analysis_results = self.analyze_dwg_files(tmp_file_path)
+                        self._display_dwg_analysis_results(analysis_results)
+                    else:
+                        # استخدام محلل المستندات لتحليل الملف
+                        analysis_results = self.document_analyzer.analyze_document(tmp_file_path, analysis_type)
+                        self._display_document_analysis_results(analysis_results)
+        
+        # عرض ملخصات المستندات المحللة سابقاً
+        st.markdown("### المستندات المحللة سابقاً")
+        
+        for doc in st.session_state.document_summaries:
+            with st.expander(f"{doc['title']} ({doc['date']})"):
+                st.markdown(f"**ملخص:** {doc['summary']}")
+                
+                st.markdown("**النقاط الرئيسية:**")
+                for point in doc['key_points']:
+                    st.markdown(f"- {point}")
+                
+                st.markdown("**الكيانات المستخرجة:**")
+                for entity, value in doc['entities'].items():
+                    st.markdown(f"- **{entity}:** {value}")
+
+    def _render_cost_estimation_tab(self):
+        """عرض تبويب تقدير التكاليف"""
+        
+        st.markdown("### تقدير التكاليف")
+        
+        # إضافة خيارات تقدير التكاليف
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            project_type = st.selectbox(
+                "نوع المشروع",
+                ["مبنى إداري", "مبنى سكني", "مدرسة", "مستشفى", "طرق", "جسور", "بنية تحتية"]
+            )
+            
+            project_location = st.selectbox(
+                "موقع المشروع",
+                ["الرياض", "جدة", "الدمام", "مكة", "المدينة", "أبها", "تبوك"]
+            )
+            
+            project_area = st.number_input("المساحة (م²)", min_value=100, max_value=100000, value=5000)
+            
+            project_duration = st.number_input("المدة (شهر)", min_value=1, max_value=60, value=18)
+        
+        with col2:
+            quality_level = st.selectbox(
+                "مستوى الجودة",
+                ["اقتصادي", "متوسط", "عالي", "فاخر"]
+            )
+            
+            include_design = st.checkbox("تضمين التصميم", value=True)
+            
+            include_supervision = st.checkbox("تضمين الإشراف", value=True)
+            
+            include_contingency = st.checkbox("تضمين احتياطي الطوارئ", value=True)
+        
+        # زر تقدير التكاليف
+        if st.button("تقدير التكاليف"):
+            with st.spinner("جاري تقدير التكاليف..."):
+                # إنشاء بيانات المناقصة
+                tender_data = {
+                    "نوع المشروع": project_type,
+                    "الموقع": project_location,
+                    "المساحة (م2)": project_area,
+                    "المدة (شهر)": project_duration,
+                    "مستوى الجودة": quality_level,
+                    "تضمين التصميم": include_design,
+                    "تضمين الإشراف": include_supervision,
+                    "تضمين احتياطي الطوارئ": include_contingency,
+                    "الميزانية التقديرية": project_area * 5000  # قيمة افتراضية
+                }
+                
+                # استخدام وحدة تكامل البيانات لتحسين التسعير
+                pricing_results = self.optimize_pricing(tender_data)
+                
+                # عرض نتائج التسعير
+                self._display_pricing_results(pricing_results)
+
+    def _render_risk_analysis_tab(self):
+        """عرض تبويب تحليل المخاطر"""
+        
+        st.markdown("### تحليل المخاطر")
+        
+        # إضافة خيارات تحليل المخاطر
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            project_type = st.selectbox(
+                "نوع المشروع",
+                ["مبنى إداري", "مبنى سكني", "مدرسة", "مستشفى", "طرق", "جسور", "بنية تحتية"],
+                key="risk_project_type"
+            )
+            
+            project_location = st.selectbox(
+                "موقع المشروع",
+                ["الرياض", "جدة", "الدمام", "مكة", "المدينة", "أبها", "تبوك"],
+                key="risk_project_location"
+            )
+            
+            project_budget = st.number_input("الميزانية (ريال)", min_value=100000, max_value=1000000000, value=10000000)
+            
+            project_duration = st.number_input("المدة (شهر)", min_value=1, max_value=60, value=18, key="risk_project_duration")
+        
+        with col2:
+            contractor_experience = st.selectbox(
+                "خبرة المقاول",
+                ["محدودة", "متوسطة", "عالية"]
+            )
+            
+            project_complexity = st.selectbox(
+                "تعقيد المشروع",
+                ["بسيط", "متوسط", "معقد", "معقد جداً"]
+            )
+            
+            market_conditions = st.selectbox(
+                "ظروف السوق",
+                ["مستقرة", "متقلبة", "غير مستقرة"]
+            )
+            
+            competition_level = st.selectbox(
+                "مستوى المنافسة",
+                ["منخفض", "متوسط", "عالي", "عالي جداً"]
+            )
+        
+        # زر تحليل المخاطر
+        if st.button("تحليل المخاطر"):
+            with st.spinner("جاري تحليل المخاطر..."):
+                # إنشاء بيانات المناقصة
+                tender_data = {
+                    "نوع المشروع": project_type,
+                    "الموقع": project_location,
+                    "الميزانية": project_budget,
+                    "المدة (شهر)": project_duration,
+                    "خبرة المقاول": contractor_experience,
+                    "تعقيد المشروع": project_complexity,
+                    "ظروف السوق": market_conditions,
+                    "مستوى المنافسة": competition_level
+                }
+                
+                # استخدام وحدة تكامل البيانات لتحليل المخاطر
+                risk_results = self.analyze_tender_data(tender_data)
+                
+                # عرض نتائج تحليل المخاطر
+                self._display_risk_analysis_results(risk_results)
+
+    def _render_ai_models_tab(self):
+        """عرض تبويب نماذج الذكاء الاصطناعي"""
+        
+        st.markdown("### نماذج الذكاء الاصطناعي")
+        
+        # عرض النماذج المتاحة
+        for model in st.session_state.ai_models:
+            with st.expander(f"{model['name']} (دقة: {model['accuracy']}%)"):
+                st.markdown(f"**الوصف:** {model['description']}")
+                st.markdown(f"**النوع:** {model['type']}")
+                st.markdown(f"**تاريخ آخر تحديث:** {model['last_updated']}")
+                
+                # إضافة زر لتدريب النموذج
+                if st.button(f"تدريب النموذج", key=f"train_{model['id']}"):
+                    with st.spinner("جاري تدريب النموذج..."):
+                        # محاكاة تدريب النموذج
+                        time.sleep(2)
+                        st.success("تم تدريب النموذج بنجاح!")
+                        
+                        # تحديث دقة النموذج
+                        for i, m in enumerate(st.session_state.ai_models):
+                            if m['id'] == model['id']:
+                                st.session_state.ai_models[i]['accuracy'] = min(99, model['accuracy'] + np.random.randint(1, 3))
+                                st.session_state.ai_models[i]['last_updated'] = datetime.now().strftime("%Y-%m-%d")
+                                break
+                        
+                        st.rerun()
+        
+        # إضافة نموذج جديد
+        st.markdown("### إضافة نموذج جديد")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            new_model_name = st.text_input("اسم النموذج")
+            new_model_description = st.text_area("وصف النموذج")
+        
+        with col2:
+            new_model_type = st.selectbox(
+                "نوع النموذج",
+                ["معالجة اللغة الطبيعية", "تعلم آلي", "رؤية حاسوبية", "شبكة عصبية"]
+            )
+            
+            new_model_accuracy = st.slider("الدقة المتوقعة", 50, 99, 75)
+        
+        if st.button("إضافة النموذج"):
+            if new_model_name and new_model_description:
+                # إضافة النموذج الجديد
+                new_model = {
+                    'id': len(st.session_state.ai_models) + 1,
+                    'name': new_model_name,
+                    'description': new_model_description,
+                    'type': new_model_type,
+                    'accuracy': new_model_accuracy,
+                    'last_updated': datetime.now().strftime("%Y-%m-%d")
+                }
+                
+                st.session_state.ai_models.append(new_model)
+                st.success("تم إضافة النموذج بنجاح!")
+                st.rerun()
+            else:
+                st.warning("يرجى ملء جميع الحقول المطلوبة")
+
+    def _generate_assistant_response(self, user_input):
+        """توليد استجابة المساعد الذكي"""
+        
+        # محاكاة استجابة المساعد الذكي
+        responses = [
+            "يمكنني مساعدتك في تحليل كراسة الشروط والمواصفات لهذه المناقصة. هل ترغب في رفع الملف للتحليل؟",
+            "بناءً على تحليل البيانات التاريخية، أنصحك بتقديم عرض سعر أقل بنسبة 5-10% من الميزانية التقديرية لزيادة فرص الفوز.",
+            "يمكنني مساعدتك في تقدير تكاليف هذا المشروع. يرجى تحديد نوع المشروع والموقع والم��احة.",
+            "تشير تحليلاتنا إلى وجود مخاطر متوسطة في هذا المشروع، أهمها ارتفاع أسعار المواد وتأخر التوريدات. هل ترغب في الحصول على تحليل مفصل للمخاطر؟",
+            "يمكنني تحليل ملفات DWG الخاصة بالمشروع لاستخراج الكميات وتقدير التكاليف. هل ترغب في رفع الملفات للتحليل؟",
+            "بناءً على تحليل المنافسين، نتوقع وجود 3-5 منافسين رئيسيين في هذه المناقصة. هل ترغب في الحصول على تحليل مفصل للمنافسين؟"
+        ]
+        
+        return np.random.choice(responses)
+
+    def _display_document_analysis_results(self, results):
+        """عرض نتائج تحليل المستندات"""
+        
+        st.markdown("### نتائج التحليل")
+        
+        # عرض ملخص التحليل
+        st.markdown(f"**ملخص:** {results.get('summary', 'لا يوجد ملخص متاح')}")
+        
+        # عرض النقاط الرئيسية
+        st.markdown("**النقاط الرئيسية:**")
+        for point in results.get('key_points', ['لا توجد نقاط رئيسية متاحة']):
+            st.markdown(f"- {point}")
+        
+        # عرض الكيانات المستخرجة
+        st.markdown("**الكيانات المستخرجة:**")
+        for entity, value in results.get('entities', {}).items():
+            st.markdown(f"- **{entity}:** {value}")
+        
+        # عرض التوصيات
+        st.markdown("**التوصيات:**")
+        for recommendation in results.get('recommendations', ['لا توجد توصيات متاحة']):
+            st.markdown(f"- {recommendation}")
+        
+        # إضافة المستند إلى قائمة المستندات المحللة
+        if 'title' in results:
+            new_doc = {
+                'id': len(st.session_state.document_summaries) + 1,
+                'title': results['title'],
+                'date': datetime.now().strftime("%Y-%m-%d"),
+                'summary': results.get('summary', ''),
+                'key_points': results.get('key_points', []),
+                'entities': results.get('entities', {})
+            }
+            
+            st.session_state.document_summaries.append(new_doc)
+            st.success("تم إضافة المستند إلى قائمة المستندات المحللة")
+
+    def _display_dwg_analysis_results(self, results):
+        """عرض نتائج تحليل ملفات DWG"""
+        
+        st.markdown("### نتائج تحليل ملف DWG")
+        
+        # عرض معلومات الملف
+        st.markdown("**معلومات الملف:**")
+        st.markdown(f"- **اسم الملف:** {results.get('file_name', 'غير معروف')}")
+        st.markdown(f"- **حجم الملف:** {results.get('file_size', 'غير معروف')}")
+        st.markdown(f"- **عدد العناصر:** {results.get('elements_count', 'غير معروف')}")
+        st.markdown(f"- **عدد الطبقات:** {results.get('layers_count', 'غير معروف')}")
+        
+        # عرض الأبعاد
+        st.markdown("**الأبعاد:**")
+        dimensions = results.get('dimensions', {})
+        st.markdown(f"- **العرض:** {dimensions.get('width', 'غير معروف')}")
+        st.markdown(f"- **الارتفاع:** {dimensions.get('height', 'غير معروف')}")
+        st.markdown(f"- **المساحة:** {dimensions.get('area', 'غير معروف')}")
+        
+        # عرض العناصر
+        st.markdown("**العناصر:**")
+        elements = results.get('elements', {})
+        for element, count in elements.items():
+            st.markdown(f"- **{element}:** {count}")
+        
+        # عرض المواد
+        st.markdown("**المواد:**")
+        for material in results.get('materials', []):
+            material_info = []
+            for key, value in material.items():
+                if key != 'name':
+                    material_info.append(f"{key}: {value}")
+            
+            st.markdown(f"- **{material.get('name', 'غير معروف')}:** {', '.join(material_info)}")
+        
+        # عرض تقدير التكلفة
+        st.markdown("**تقدير التكلفة:**")
+        cost_estimate = results.get('cost_estimate', {})
+        st.markdown(f"- **تكلفة المواد:** {cost_estimate.get('materials', 0):,} ريال")
+        st.markdown(f"- **تكلفة العمالة:** {cost_estimate.get('labor', 0):,} ريال")
+        st.markdown(f"- **تكلفة المعدات:** {cost_estimate.get('equipment', 0):,} ريال")
+        st.markdown(f"- **التكلفة الإجمالية:** {cost_estimate.get('total', 0):,} ريال")
+        
+        # عرض التوصيات
+        st.markdown("**التوصيات:**")
+        for recommendation in results.get('recommendations', ['ل�� توجد توصيات متاحة']):
+            st.markdown(f"- {recommendation}")
+
+    def _display_pricing_results(self, results):
+        """عرض نتائج تحسين التسعير"""
+        
+        st.markdown("### نتائج تحسين التسعير")
+        
+        # عرض نطاق السعر المقترح
+        st.markdown("**نطاق السعر المقترح:**")
+        st.markdown(f"- **الحد الأدنى:** {results.get('min_price', 0):,.0f} ريال")
+        st.markdown(f"- **السعر الأمثل:** {results.get('optimal_price', 0):,.0f} ريال")
+        st.markdown(f"- **الحد الأقصى:** {results.get('max_price', 0):,.0f} ريال")
+        
+        # عرض تحليل حساسية السعر
+        st.markdown("**تحليل حساسية السعر:**")
+        
+        price_sensitivity = results.get('price_sensitivity', [])
+        if price_sensitivity:
+            # إنشاء DataFrame لتحليل حساسية السعر
+            sensitivity_data = {
+                'عامل السعر': [item['price_factor'] for item in price_sensitivity],
+                'السعر (ريال)': [item['price'] for item in price_sensitivity],
+                'احتمالية الفوز (%)': [item['win_probability'] for item in price_sensitivity],
+                'الربح (ريال)': [item['profit'] for item in price_sensitivity],
+                'القيمة المتوقعة (ريال)': [item['expected_value'] for item in price_sensitivity]
+            }
+            
+            sensitivity_df = pd.DataFrame(sensitivity_data)
+            st.dataframe(sensitivity_df)
+            
+            # إنشاء رسم بياني لتحليل حساسية السعر
+            fig = px.line(sensitivity_df, x='السعر (ريال)', y=['احتمالية الفوز (%)', 'القيمة المتوقعة (ريال)'], title='تحليل حساسية السعر')
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض الموقف التنافسي في السوق
+        st.markdown("**الموقف التنافسي في السوق:**")
+        market_position = results.get('market_position', {})
+        st.markdown(f"- **الموقف التنافسي:** {market_position.get('market_position', 'غير معروف')}")
+        st.markdown(f"- **الشريحة السعرية:** {market_position.get('price_percentile', 0)}%")
+        st.markdown(f"- **عدد المنافسين بأسعار أقل:** {market_position.get('competitors_below', 0)}")
+        st.markdown(f"- **عدد المنافسين بأسعار أعلى:** {market_position.get('competitors_above', 0)}")
+        st.markdown(f"- **تنافسية السعر:** {market_position.get('price_competitiveness', 'غير معروفة')}")
+        
+        # عرض التوصيات
+        st.markdown("**التوصيات:**")
+        for recommendation in results.get('recommendations', ['لا توجد توصيات متاحة']):
+            st.markdown(f"- {recommendation}")
+
+    def _display_risk_analysis_results(self, results):
+        """عرض نتائج تحليل المخاطر"""
+        
+        st.markdown("### نتائج تحليل المخاطر")
+        
+        # عرض ملخص تحليل المخاطر
+        st.markdown(f"**ملخص:** {results.get('summary', 'لا يوجد ملخص متاح')}")
+        
+        # عرض تحليل المخاطر
+        st.markdown("**تحليل المخاطر:**")
+        
+        risk_analysis = results.get('risk_analysis', [])
+        if risk_analysis:
+            # إنشاء DataFrame لتحليل المخاطر
+            risk_data = {
+                'المخاطرة': [risk['risk'] for risk in risk_analysis],
+                'الاحتمالية': [risk['probability'] for risk in risk_analysis],
+                'التأثير': [risk['impact'] for risk in risk_analysis],
+                'استراتيجية التخفيف': [risk['mitigation'] for risk in risk_analysis]
+            }
+            
+            risk_df = pd.DataFrame(risk_data)
+            st.dataframe(risk_df)
+            
+            # إنشاء مصفوفة المخاطر
+            st.markdown("**مصفوفة المخاطر:**")
+            
+            # تحويل درجات المخاطرة إلى قيم رقمية للرسم البياني
+            probability_levels = {
+                "منخفضة": 1,
+                "متوسطة": 2,
+                "عالية": 3
+            }
+            
+            impact_levels = {
+                "منخفض": 1,
+                "متوسط": 2,
+                "عالي": 3,
+                "عالي جداً": 4
+            }
+            
+            # إنشاء DataFrame للرسم البياني
+            chart_data = []
+            for risk in risk_analysis:
+                chart_data.append({
+                    "المخاطرة": risk['risk'],
+                    "الاحتمالية": probability_levels.get(risk['probability'], 0),
+                    "التأثير": impact_levels.get(risk['impact'], 0)
+                })
+            
+            chart_df = pd.DataFrame(chart_data)
+            
+            fig = px.scatter(
+                chart_df,
+                x="الاحتمالية",
+                y="التأثير",
+                text="المخاطرة",
+                size=[3] * len(chart_df),
+                color="التأثير",
+                color_continuous_scale=px.colors.sequential.Reds
+            )
+            
+            fig.update_layout(
+                xaxis=dict(
+                    tickmode='array',
+                    tickvals=[1, 2, 3],
+                    ticktext=['منخفضة', 'متوسطة', 'عالية']
+                ),
+                yaxis=dict(
+                    tickmode='array',
+                    tickvals=[1, 2, 3, 4],
+                    ticktext=['منخفض', 'متوسط', 'عالي', 'عالي جداً']
+                )
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض تحليل التكاليف
+        st.markdown("**تحليل التكاليف:**")
+        
+        cost_analysis = results.get('cost_analysis', {})
+        if cost_analysis:
+            st.markdown(f"**الميزانية الإجمالية:** {cost_analysis.get('total_budget', 0):,.0f} ريال")
+            
+            # عرض توزيع التكاليف
+            st.markdown("**توزيع التكاليف:**")
+            
+            cost_breakdown = cost_analysis.get('cost_breakdown', [])
+            if cost_breakdown:
+                # إنشاء DataFrame لتوزيع التكاليف
+                cost_data = {
+                    'الفئة': [item['category'] for item in cost_breakdown],
+                    'المبلغ (ريال)': [item['amount'] for item in cost_breakdown],
+                    'النسبة (%)': [item['percentage'] for item in cost_breakdown]
+                }
+                
+                cost_df = pd.DataFrame(cost_data)
+                
+                # إنشاء رسم بياني لتوزيع التكاليف
+                fig = px.pie(cost_df, values='المبلغ (ريال)', names='الفئة', title='توزيع التكاليف')
+                st.plotly_chart(fig, use_container_width=True)
+            
+            # عرض فرص توفير التكاليف
+            st.markdown("**فرص توفير التكاليف:**")
+            
+            cost_saving = cost_analysis.get('cost_saving_opportunities', [])
+            if cost_saving:
+                for item in cost_saving:
+                    st.markdown(f"- **{item['item']}:** {item['potential_saving']:,.0f} ريال")
+        
+        # عرض التوصيات
+        st.markdown("**التوصيات:**")
+        for recommendation in results.get('recommendations', ['لا توجد توصيات متاحة']):
+            st.markdown(f"- {recommendation}")

modules/ai_assistant/assistant.py

@@ -0,0 +1,444 @@
+"""
+وحدة المساعد الذكي لنظام إدارة المناقصات - Hybrid Face
+"""
+
+import os
+import logging
+import threading
+import datetime
+import json
+import re
+from pathlib import Path
+
+# تهيئة السجل
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger('ai_assistant')
+
+class AIAssistant:
+    """المساعد الذكي"""
+    
+    def __init__(self, config=None, db=None):
+        """تهيئة المساعد الذكي"""
+        self.config = config
+        self.db = db
+        self.processing_in_progress = False
+        self.current_query = None
+        self.processing_results = {}
+        self.conversation_history = []
+        
+        # إعدادات المساعد الذكي
+        self.ai_model = config.AI_MODEL if config and hasattr(config, 'AI_MODEL') else "gpt-4"
+        self.ai_temperature = config.AI_TEMPERATURE if config and hasattr(config, 'AI_TEMPERATURE') else 0.7
+        self.ai_max_tokens = config.AI_MAX_TOKENS if config and hasattr(config, 'AI_MAX_TOKENS') else 2000
+        
+        # إنشاء مجلد المساعد الذكي إذا لم يكن موجوداً
+        if config and hasattr(config, 'EXPORTS_PATH'):
+            self.exports_path = Path(config.EXPORTS_PATH)
+        else:
+            self.exports_path = Path('data/exports')
+            
+        if not self.exports_path.exists():
+            self.exports_path.mkdir(parents=True, exist_ok=True)
+    
+    def process_query(self, query, context=None, callback=None):
+        """معالجة استعلام المستخدم"""
+        if self.processing_in_progress:
+            logger.warning("هناك عملية معالجة جارية بالفعل")
+            return False
+        
+        self.processing_in_progress = True
+        self.current_query = query
+        self.processing_results = {
+            "query": query,
+            "context": context,
+            "processing_start_time": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+            "status": "جاري المعالجة",
+            "response": "",
+            "suggestions": [],
+            "references": []
+        }
+        
+        # إضافة الاستعلام إلى سجل المحادثة
+        self.conversation_history.append({
+            "role": "user",
+            "content": query,
+            "timestamp": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        })
+        
+        # بدء المعالجة في خيط منفصل
+        thread = threading.Thread(
+            target=self._process_query_thread,
+            args=(query, context, callback)
+        )
+        thread.daemon = True
+        thread.start()
+        
+        return True
+    
+    def _process_query_thread(self, query, context, callback):
+        """خيط معالجة الاستعلام"""
+        try:
+            # تحليل الاستعلام
+            query_type = self._analyze_query(query)
+            
+            # معالجة الاستعلام بناءً على نوعه
+            if query_type == "document_analysis":
+                response = self._handle_document_analysis_query(query, context)
+            elif query_type == "pricing":
+                response = self._handle_pricing_query(query, context)
+            elif query_type == "risk_analysis":
+                response = self._handle_risk_analysis_query(query, context)
+            elif query_type == "project_management":
+                response = self._handle_project_management_query(query, context)
+            elif query_type == "reporting":
+                response = self._handle_reporting_query(query, context)
+            else:
+                response = self._handle_general_query(query, context)
+            
+            # توليد اقتراحات
+            suggestions = self._generate_suggestions(query_type, query, response)
+            
+            # تحديث نتائج المعالجة
+            self.processing_results["response"] = response
+            self.processing_results["query_type"] = query_type
+            self.processing_results["suggestions"] = suggestions
+            self.processing_results["status"] = "اكتملت المعالجة"
+            self.processing_results["processing_end_time"] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            
+            # إضافة الاستجابة إلى سجل المحادثة
+            self.conversation_history.append({
+                "role": "assistant",
+                "content": response,
+                "timestamp": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            })
+            
+            logger.info(f"اكتملت معالجة الاستعلام: {query[:50]}...")
+            
+        except Exception as e:
+            logger.error(f"خطأ في معالجة الاستعلام: {str(e)}")
+            self.processing_results["status"] = "فشلت ا��معالجة"
+            self.processing_results["error"] = str(e)
+            
+            # إضافة رسالة الخطأ إلى سجل المحادثة
+            self.conversation_history.append({
+                "role": "system",
+                "content": f"حدث خطأ أثناء معالجة الاستعلام: {str(e)}",
+                "timestamp": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            })
+        
+        finally:
+            self.processing_in_progress = False
+            
+            # استدعاء دالة الاستجابة إذا تم توفيرها
+            if callback and callable(callback):
+                callback(self.processing_results)
+    
+    def _analyze_query(self, query):
+        """تحليل نوع الاستعلام"""
+        query = query.lower()
+        
+        # تحديد نوع الاستعلام بناءً على الكلمات المفتاحية
+        if any(keyword in query for keyword in ["تحليل المستند", "تحليل وثيقة", "استخراج بيانات", "قراءة مستند"]):
+            return "document_analysis"
+        elif any(keyword in query for keyword in ["تسعير", "سعر", "تكلفة", "ميزانية", "تقدير"]):
+            return "pricing"
+        elif any(keyword in query for keyword in ["مخاطر", "تحليل المخاطر", "تقييم المخاطر"]):
+            return "risk_analysis"
+        elif any(keyword in query for keyword in ["مشروع", "إدارة المشروع", "جدول زمني", "خطة"]):
+            return "project_management"
+        elif any(keyword in query for keyword in ["تقرير", "إحصائيات", "تحليل البيانات", "رسم بياني"]):
+            return "reporting"
+        else:
+            return "general"
+    
+    def _handle_document_analysis_query(self, query, context):
+        """معالجة استعلام تحليل المستندات"""
+        # محاكاة استجابة المساعد الذكي لاستعلام تحليل المستندات
+        response = """
+يمكنني مساعدتك في تحليل المستندات واستخراج المعلومات المهمة منها. لتحليل مستند، يرجى اتباع الخطوات التالية:
+
+1. انتقل إلى وحدة "تحليل المستندات" من القائمة الجانبية.
+2. انقر على زر "تحميل مستند" واختر المستند المراد تحليله.
+3. حدد نوع المستند (مناقصة، عقد، مواصفات فنية، إلخ).
+4. انقر على زر "تحليل" لبدء عملية التحليل.
+
+سيقوم النظام باستخراج المعلومات التالية من المستند:
+- البنود والكميات
+- الكيانات (العميل، الموقع، المقاول، إلخ)
+- التواريخ المهمة
+- المبالغ والتكاليف
+- المخاطر المحتملة
+
+بعد اكتمال التحليل، يمكنك مراجعة النتائج وتعديلها إذا لزم الأمر، ثم استخدامها في وحدات النظام الأخرى مثل التسعير وتحليل المخاطر.
+"""
+        
+        # إضافة مراجع ذات صلة
+        self.processing_results["references"] = [
+            {"title": "دليل استخدام وحدة تحليل المستندات", "type": "manual"},
+            {"title": "أنواع المستندات المدعومة", "type": "documentation"},
+            {"title": "تقنيات استخراج البيانات من المستندات", "type": "article"}
+        ]
+        
+        return response
+    
+    def _handle_pricing_query(self, query, context):
+        """معالجة استعلام التسعير"""
+        # محاكاة استجابة المساعد الذكي لاستعلام التسعير
+        response = """
+يمكنني مساعدتك في تسعير المشاريع وتقدير التكاليف. لإنشاء تسعير لمشروع، يرجى اتباع الخطوات التالية:
+
+1. انتقل إلى وحدة "التسعير المتكامل" من القائمة الجانبية.
+2. اختر المشروع المراد تسعيره أو أنشئ مشروعاً جديداً.
+3. أدخل بنود المشروع والكميات التقديرية (يمكن استيرادها من نتائج تحليل المستندات).
+4. حدد الموارد المطلوبة (مواد، معدات، عمالة).
+5. اختر استراتيجية التسعير المناسبة:
+   - شاملة: تغطية كاملة للتكاليف والمخاطر مع هامش ربح مناسب.
+   - تنافسية: تخفيض الهوامش لتقديم سعر تنافسي.
+   - متوازنة: توازن بين الربحية والتنافسية.
+6. انقر على زر "حساب التسعير" لإنشاء التسعير.
+
+سيقوم النظام بحساب:
+- التكاليف المباشرة (بنود المشروع)
+- التكاليف غير المباشرة (نفقات عامة، إدارية، ربح)
+- تكاليف المخاطر
+- ضريبة القيمة المضافة
+- السعر النهائي
+
+يمكنك تعديل المعلمات وإعادة حساب التسعير، ثم تصدير النتائج إلى تقرير مفصل.
+"""
+        
+        # إضافة مراجع ذات صلة
+        self.processing_results["references"] = [
+            {"title": "دليل استخدام وحدة التسعير المتكامل", "type": "manual"},
+            {"title": "استراتيجيات التسعير", "type": "documentation"},
+            {"title": "حساب التكاليف غير المباشرة", "type": "article"}
+        ]
+        
+        return response
+    
+    def _handle_risk_analysis_query(self, query, context):
+        """معالجة استعلام تحليل المخاطر"""
+        # محاكاة استجابة المساعد الذكي لاستعلام تحليل المخاطر
+        response = """
+يمكنني مساعدتك في تحليل وإدارة مخاطر المشروع. لإجراء تحليل للمخاطر، يرجى اتباع الخطوات التالية:
+
+1. انتقل إلى وحدة "تحليل المخاطر" من القائمة الجانبية.
+2. اختر المشروع المراد تحليل مخاطره.
+3. اختر طريقة التحليل:
+   - شاملة: تحليل مفصل يغطي جميع جوانب المشروع.
+   - أساسية: تحليل سريع للمخاطر الرئيسية.
+4. انقر على زر "تحليل المخاطر" لبدء التحليل.
+
+سيقوم النظام بما يلي:
+- تحديد المخاطر المحتملة بناءً على بيانات المشروع
+- تصنيف المخاطر إلى فئات (فني، مالي، إداري، إلخ)
+- إنشاء مصفوفة المخاطر (الاحتمالية × التأثير)
+- تطوير استراتيجيات التخفيف لكل مخاطرة
+- إنشاء ملخص للمخاطر وتوصيات
+
+يمكنك مراجعة نتائج التحليل وتعديلها، ثم تصدير التقرير النهائي واستخدامه في خطة إدارة المشروع.
+"""
+        
+        # إضافة مراجع ذات صلة
+        self.processing_results["references"] = [
+            {"title": "دليل استخدام وحدة تحليل المخاطر", "type": "manual"},
+            {"title": "منهجيات تحليل المخاطر", "type": "documentation"},
+            {"title": "استراتيجيات التخفيف من المخاطر", "type": "article"}
+        ]
+        
+        return response
+    
+    def _handle_project_management_query(self, query, context):
+        """معالجة استعلام إدارة المشاريع"""
+        # محاكاة استجابة المساعد الذكي لاستعلام إدارة المشاريع
+        response = """
+يمكنني مساعدتك في إدارة المشاريع وتتبع تقدمها. لإدارة مشروع، يرجى اتباع الخطوات التالية:
+
+1. انتقل إلى وحدة "إدارة المشاريع" من القائمة الجانبية.
+2. أنشئ مشروعاً جديداً أو اختر مشروعاً موجوداً.
+3. أدخل معلومات المشروع الأساسية (الاسم، العميل، الوصف، التواريخ).
+4. أضف بنود المشروع (يمكن استيرادها من نتائج تحليل المستندات).
+5. أنشئ الجدول الزمني للمشروع وحدد المراحل والمهام.
+6. عين الموارد للمهام وحدد التبعيات بينها.
+
+يمكنك استخدام وحدة إدارة المشاريع لـ:
+- تتبع تقدم المشروع ومقارنته بالخطة
+- إدارة الموارد وتوزيعها
+- متابعة المشكلات والمخاطر
+- إدارة التغييرات في نطاق العمل
+- إنشاء تقارير حالة المشروع
+
+كما يمكنك دمج نتائج التسعير وتحليل المخاطر في خطة المشروع لإدارة شاملة.
+"""
+        
+        # إضافة مراجع ذات صلة
+        self.processing_results["references"] = [
+            {"title": "دليل استخدام وحدة إدارة المشاريع", "type": "manual"},
+            {"title": "أفضل ممارسات إدارة المشاريع", "type": "documentation"},
+            {"title": "إنشاء جداول زمنية فعالة", "type": "article"}
+        ]
+        
+        return response
+    
+    def _handle_reporting_query(self, query, context):
+        """معالجة استعلام التقارير"""
+        # محاكاة استجابة المساعد الذكي لاستعلام التقارير
+        response = """
+يمكنني مساعدتك في إنشاء تقارير وتحليلات للمشاريع والمناقصات. لإنشاء تقرير، يرجى اتباع الخطوات التالية:
+
+1. انتقل إلى وحدة "التقارير والتحليلات" من القائمة الجانبية.
+2. اختر نوع التقرير:
+   - تقرير المشروع: معلومات شاملة عن مشروع محدد
+   - تقرير التسعير: تفاصيل تسعير مشروع أو مناقصة
+   - تقرير المخاطر: تحليل مخاطر المشروع واستراتيجيات التخفيف
+   - تقرير الأداء: مقارنة الأداء الفعلي بالمخطط
+   - تقرير مالي: تحليل مالي للمشاريع والمناقصات
+3. حدد معلمات التقرير (المشروع، الفترة الزمنية، إلخ).
+4. انقر على زر "إنشاء التقرير".
+
+يمكنك تخصيص التقارير بإضافة أو إزالة أقسام، وتغيير طريقة عرض البيانات (جداول، رسوم بيانية، إلخ).
+
+التقارير المنشأة يمكن:
+- تصديرها بتنسيقات مختلفة (PDF، Excel، Word)
+- مشاركتها مع أعضاء الفريق أو العملاء
+- جدولتها للإنشاء التلقائي بشكل دوري
+- حفظها كقوالب لاستخدامها في المستقبل
+"""
+        
+        # إضافة مراجع ذات صلة
+        self.processing_results["references"] = [
+            {"title": "دليل استخدام وحدة التقارير والتحليلات", "type": "manual"},
+            {"title": "أنواع التقارير المتاحة", "type": "documentation"},
+            {"title": "إنشاء رسوم بيانية فعالة", "type": "article"}
+        ]
+        
+        return response
+    
+    def _handle_general_query(self, query, context):
+        """معالجة استعلام عام"""
+        # محاكاة استجابة المساعد الذكي لاستعلام عام
+        response = """
+مرحباً بك في المساعد الذكي لنظام إدارة المناقصات Hybrid Face. يمكنني مساعدتك في مجموعة متنوعة من المهام المتعلقة بإدارة المناقصات والمشاريع.
+
+يمكنني مساعدتك في:
+- تحليل مستندات المناقصات واستخراج المعلومات المهمة منها
+- تسعير المشاريع وتقدير التكاليف
+- تحليل وإدارة مخاطر المشاريع
+- إدارة المشاريع وتتبع تقدمها
+- إنشاء تقارير وتحليلات
+
+للحصول على مساعدة محددة، يرجى طرح سؤال يتعلق بإحدى هذه المجالات. على سبيل المثال:
+- "كيف يمكنني تحليل مستند مناقصة؟"
+- "ساعدني في تسعير مشروع جديد"
+- "كيف أقوم بتحليل مخاطر المشروع؟"
+- "أريد إنشاء تقرير عن حالة المشروع"
+
+يمكنك أيضاً استخدام الوحدات المختلفة في النظام مباشرة من القائمة الجانبية.
+"""
+        
+        # إضافة مراجع ذات صلة
+        self.processing_results["references"] = [
+            {"title": "دليل المستخدم الشامل", "type": "manual"},
+            {"title": "نظرة عامة على النظام", "type": "documentation"},
+            {"title": "الأسئلة الشائعة", "type": "faq"}
+        ]
+        
+        return response
+    
+    def _generate_suggestions(self, query_type, query, response):
+        """توليد اقتراحات للمستخدم بناءً على الاستعلام والاستجابة"""
+        suggestions = []
+        
+        if query_type == "document_analysis":
+            suggestions = [
+                "كيف يمكنني استيراد نتائج تحليل المستندات إلى وحدة التسعير؟",
+                "ما هي أنواع المستندات المدعومة للتحليل؟",
+                "كيف يمكنني تحسين دقة تحليل المستندات؟"
+            ]
+        elif query_type == "pricing":
+            suggestions = [
+                "ما هي استراتيجية التسعير المناسبة لمشروعي؟",
+                "كيف يمكنني حساب التكاليف غير المباشرة؟",
+                "كيف أضيف تكاليف المخاطر إلى التسعير؟"
+            ]
+        elif query_type == "risk_analysis":
+            suggestions = [
+                "ما هي أفضل استراتيجيات التخفيف من المخاطر؟",
+                "كيف يمكنني تحديد المخاطر الحرجة في المشروع؟",
+                "كيف أدمج تحليل المخاطر في خطة المشروع؟"
+            ]
+        elif query_type == "project_management":
+            suggestions = [
+                "كيف أنشئ جدولاً زمنياً فعالاً للمشروع؟",
+                "كيف أتتبع تقدم المشروع مقارنة بالخطة؟",
+                "كيف أدير التغييرات في نطاق المشروع؟"
+            ]
+        elif query_type == "reporting":
+            suggestions = [
+                "ما هي أنواع التقارير المتاحة في النظام؟",
+                "كيف يمكنني تخصيص تقرير المشروع؟",
+                "كيف أقوم بجدولة إنشاء تقارير دورية؟"
+            ]
+        else:
+            suggestions = [
+                "كيف يمكنني البدء باستخدام النظام؟",
+                "ما هي الوحدات المتاحة في النظام؟",
+                "كيف يمكنني إنشاء مشروع جديد؟"
+            ]
+        
+        return suggestions
+    
+    def get_processing_status(self):
+        """الحصول على حالة المعالجة الحالية"""
+        if not self.processing_in_progress:
+            if not self.processing_results:
+                return {"status": "لا توجد معالجة جارية"}
+            else:
+                return {"status": self.processing_results.get("status", "غير معروف")}
+        
+        return {
+            "status": "جاري المعالجة",
+            "query": self.current_query,
+            "start_time": self.processing_results.get("processing_start_time")
+        }
+    
+    def get_processing_results(self):
+        """الحصول على نتائج المعالجة"""
+        return self.processing_results
+    
+    def get_conversation_history(self, limit=10):
+        """الحصول على سجل المحادثة"""
+        if limit and limit > 0:
+            return self.conversation_history[-limit:]
+        return self.conversation_history
+    
+    def clear_conversation_history(self):
+        """مسح سجل المحادثة"""
+        self.conversation_history = []
+        return True
+    
+    def export_conversation_history(self, output_path=None):
+        """تصدير سجل المحادثة إلى ملف JSON"""
+        if not self.conversation_history:
+            logger.warning("لا يوجد سجل محادثة للتصدير")
+            return None
+        
+        if not output_path:
+            # إنشاء اسم ملف افتراضي
+            timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+            filename = f"conversation_history_{timestamp}.json"
+            output_path = os.path.join(self.exports_path, filename)
+        
+        try:
+            with open(output_path, 'w', encoding='utf-8') as f:
+                json.dump(self.conversation_history, f, ensure_ascii=False, indent=4)
+            
+            logger.info(f"تم تصدير سجل المحادثة إلى: {output_path}")
+            return output_path
+        
+        except Exception as e:
+            logger.error(f"خطأ في تصدير سجل المحادثة: {str(e)}")
+            return None

modules/ai_assistant/contract_analyzer.py

@@ -0,0 +1,1333 @@
+"""
+محلل العقود المتقدم - وحدة تحليل العقود والمناقصات باستخدام الذكاء الاصطناعي
+
+هذا الملف يحتوي على الفئات والدوال اللازمة لتحليل العقود والمناقصات باستخدام نماذج OpenAI وClaude.
+"""
+
+import os
+import json
+import re
+import time
+import requests
+from datetime import datetime
+import pandas as pd
+import numpy as np
+from pathlib import Path
+import tempfile
+import base64
+import io
+import streamlit as st
+
+# محاكاة استيراد مكتبات الذكاء الاصطناعي
+try:
+    import openai
+    import anthropic
+    from transformers import pipeline
+    import torch
+    import nltk
+    import gensim
+    MODELS_AVAILABLE = True
+except ImportError:
+    MODELS_AVAILABLE = False
+
+class ContractAnalyzer:
+    """فئة تحليل العقود والمناقصات باستخدام الذكاء الاصطناعي"""
+    
+    def __init__(self, api_key_source="security_section"):
+        """
+        تهيئة محلل العقود
+        
+        المعلمات:
+            api_key_source (str): مصدر مفتاح API، إما "security_section" أو "manual"
+        """
+        self.api_key_source = api_key_source
+        self.openai_api_key = None
+        self.claude_api_key = None
+        self.hybrid_environment = True
+        
+        # تهيئة مفاتيح API
+        self._initialize_api_keys()
+        
+        # تهيئة نماذج الذكاء الاصطناعي
+        self._initialize_ai_models()
+    
+    def _initialize_api_keys(self):
+        """تهيئة مفاتيح API"""
+        if self.api_key_source == "security_section":
+            # محاكاة الحصول على مفاتيح API من قسم الأمان
+            self.openai_api_key = "sk-security-section-openai-key"
+            self.claude_api_key = "sk-security-section-claude-key"
+        else:
+            # استخدام مفاتيح API المدخلة يدوياً
+            self.openai_api_key = st.session_state.get("openai_api_key", "")
+            self.claude_api_key = st.session_state.get("claude_api_key", "")
+    
+    def _initialize_ai_models(self):
+        """تهيئة نماذج الذكاء الاصطناعي"""
+        if MODELS_AVAILABLE:
+            # تهيئة نماذج OpenAI
+            if self.openai_api_key:
+                openai.api_key = self.openai_api_key
+            
+            # تهيئة نماذج Claude
+            if self.claude_api_key:
+                self.claude_client = anthropic.Anthropic(api_key=self.claude_api_key)
+            
+            # تهيئة نماذج Hugging Face
+            self.summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
+            self.ner_model = pipeline("ner", model="dbmdz/bert-large-cased-finetuned-conll03-english")
+            
+            # تهيئة NLTK
+            nltk.download('punkt', quiet=True)
+            nltk.download('stopwords', quiet=True)
+    
+    def analyze_contract(self, file_path, analysis_type="comprehensive"):
+        """
+        تحليل العقد باستخدام الذكاء الاصطناعي
+        
+        المعلمات:
+            file_path (str): مسار ملف العقد
+            analysis_type (str): نوع التحليل، إما "comprehensive" أو "quick" أو "legal" أو "financial"
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # استخراج النص من الملف
+        contract_text = self._extract_text_from_file(file_path)
+        
+        # تحليل العقد باستخدام الذكاء الاصطناعي
+        if analysis_type == "comprehensive":
+            return self._comprehensive_analysis(contract_text, os.path.basename(file_path))
+        elif analysis_type == "quick":
+            return self._quick_analysis(contract_text, os.path.basename(file_path))
+        elif analysis_type == "legal":
+            return self._legal_analysis(contract_text, os.path.basename(file_path))
+        elif analysis_type == "financial":
+            return self._financial_analysis(contract_text, os.path.basename(file_path))
+        else:
+            return self._comprehensive_analysis(contract_text, os.path.basename(file_path))
+    
+    def analyze_tender(self, file_path, analysis_type="comprehensive"):
+        """
+        تحليل المناقصة باستخدام الذكاء الاصطناعي
+        
+        المعلمات:
+            file_path (str): مسار ملف المناقصة
+            analysis_type (str): نوع التحليل، إما "comprehensive" أو "quick" أو "technical" أو "financial"
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # استخراج النص من الملف
+        tender_text = self._extract_text_from_file(file_path)
+        
+        # تحليل المناقصة باس��خدام الذكاء الاصطناعي
+        if analysis_type == "comprehensive":
+            return self._comprehensive_tender_analysis(tender_text, os.path.basename(file_path))
+        elif analysis_type == "quick":
+            return self._quick_tender_analysis(tender_text, os.path.basename(file_path))
+        elif analysis_type == "technical":
+            return self._technical_tender_analysis(tender_text, os.path.basename(file_path))
+        elif analysis_type == "financial":
+            return self._financial_tender_analysis(tender_text, os.path.basename(file_path))
+        else:
+            return self._comprehensive_tender_analysis(tender_text, os.path.basename(file_path))
+    
+    def analyze_dwg_file(self, file_path):
+        """
+        تحليل ملف DWG باستخدام الذكاء الاصطناعي
+        
+        المعلمات:
+            file_path (str): مسار ملف DWG
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # محاكاة تحليل ملف DWG
+        return self._simulate_dwg_analysis(file_path)
+    
+    def compare_contracts(self, file_path1, file_path2):
+        """
+        مقارنة عقدين باستخدام الذكاء الاصطناعي
+        
+        المعلمات:
+            file_path1 (str): مسار الملف الأول
+            file_path2 (str): مسار الملف الثاني
+            
+        العوائد:
+            dict: نتائج المقارنة
+        """
+        # استخراج النص من الملفين
+        text1 = self._extract_text_from_file(file_path1)
+        text2 = self._extract_text_from_file(file_path2)
+        
+        # مقارنة العقدين باستخدام الذكاء الاصطناعي
+        return self._compare_documents(text1, text2, os.path.basename(file_path1), os.path.basename(file_path2))
+    
+    def extract_key_terms(self, file_path):
+        """
+        استخراج الشروط الرئيسية من العقد
+        
+        المعلمات:
+            file_path (str): مسار ملف العقد
+            
+        العوائد:
+            dict: الشروط الرئيسية المستخرجة
+        """
+        # استخراج النص من الملف
+        contract_text = self._extract_text_from_file(file_path)
+        
+        # استخراج الشروط الرئيسية باستخدام الذكاء الاصطناعي
+        return self._extract_key_terms_from_text(contract_text)
+    
+    def identify_risks(self, file_path):
+        """
+        تحديد المخاطر في العقد
+        
+        المعلمات:
+            file_path (str): مسار ملف العقد
+            
+        العوائد:
+            dict: المخاطر المحددة
+        """
+        # استخراج النص من الملف
+        contract_text = self._extract_text_from_file(file_path)
+        
+        # تحديد المخاطر باستخدام الذكاء الاصطناعي
+        return self._identify_risks_in_text(contract_text)
+    
+    def suggest_improvements(self, file_path):
+        """
+        اقتراح تحسينات للعقد
+        
+        المعلمات:
+            file_path (str): مسار ملف العقد
+            
+        العوائد:
+            dict: التحسينات المقترحة
+        """
+        # استخراج النص من الملف
+        contract_text = self._extract_text_from_file(file_path)
+        
+        # اقتراح تحسينات باستخدام الذكاء الاصطناعي
+        return self._suggest_improvements_for_text(contract_text)
+    
+    def _extract_text_from_file(self, file_path):
+        """
+        استخراج النص من الملف
+        
+        المعلمات:
+            file_path (str): مسار الملف
+            
+        العوائد:
+            str: النص المستخرج
+        """
+        # محاكاة استخراج النص من الملف
+        file_extension = os.path.splitext(file_path)[1].lower()
+        
+        # محاكاة نص العقد
+        if "contract" in file_path.lower() or "عقد" in file_path:
+            return """
+            عقد إنشاء مبنى إداري
+            
+            المادة الأولى: أطراف العقد
+            الطرف الأول: وزارة المالية، ويمثلها السيد/ أحمد محمد علي، بصفته وكيل الوزارة للمشاريع.
+            الطرف الثاني: شركة الإنشاءات المتطورة، ويمثلها السيد/ خالد عبدالله محمد، بصفته المدير العام.
+            
+            المادة الثانية: موضوع العقد
+            يتعهد الطرف الثاني بتنفيذ مشروع إنشاء مبنى إداري لصالح الطرف الأول وفقاً للمواصفات والشروط المرفقة بهذا العقد.
+            
+            المادة الثالثة: قيمة العقد
+            قيمة العقد الإجمالية هي 25,000,000 ريال (خمسة وعشرون مليون ريال) شاملة جميع الضرائب والرسوم.
+            
+            المادة الرابعة: مدة التنفيذ
+            مدة تنفيذ المشروع 18 شهراً تبدأ من تاريخ استلام الموقع.
+            
+            المادة الخامسة: الدفعات
+            يتم سداد قيمة العقد على دفعات شهرية حسب نسبة الإنجاز، مع احتجاز 10% من قيمة كل دفعة كضمان حسن التنفيذ.
+            
+            المادة السادسة: الضمانات
+            يقدم الطرف الثاني ضماناً نهائياً بنسبة 5% من قيمة العقد ساري المفعول حتى انتهاء فترة الضمان.
+            
+            المادة السابعة: غرامات التأخير
+            في حالة تأخر الطرف الثاني عن التنفيذ في الموعد المحدد، يتم تطبيق غرامة تأخير بنسبة 1% من قيمة العقد عن كل أسبوع تأخير بحد أقصى 10% من قيمة العقد.
+            
+            المادة الثامنة: فترة الضمان
+            فترة ضمان المشروع سنة واحدة من تاريخ الاستلام الابتدائي.
+            
+            المادة التاسعة: فسخ العقد
+            يحق للطرف الأول فسخ العقد في حالة إخلال الطرف الثاني بالتزاماته التعاقدية بعد إنذاره كتابياً.
+            
+            المادة العاشرة: تسوية النزاعات
+            في حالة نشوء أي نزاع بين الطرفين، يتم حله ودياً، وفي حالة تعذر ذلك يتم اللجوء إلى التحكيم وفقاً لأنظمة المملكة العربية السعودية.
+            
+            المادة الحادية عشر: القانون الواجب التطبيق
+            تخضع جميع بنود هذا العقد لأنظمة المملكة العربية السعودية.
+            
+            حرر هذا العقد من نسختين أصليتين بتاريخ 15/03/2024م.
+            
+            الطرف الأول                                  الطرف الثاني
+            وزارة المالية                               شركة الإنشاءات المتطورة
+            """
+        elif "tender" in file_path.lower() or "مناقصة" in file_path:
+            return """
+            كراسة الشروط والمواصفات
+            مناقصة إنشاء مبنى إداري
+            
+            أولاً: معلومات المناقصة
+            رقم المناقصة: T-2024-001
+            الجهة المالكة: وزارة المالية
+            موقع المشروع: الرياض - حي العليا
+            تاريخ الطرح: 01/03/2024م
+            تاريخ الإقفال: 15/04/2024م
+            
+            ثانياً: وصف المشروع
+            يتكون المشروع من إنشاء مبنى إداري مكون من 5 طوابق بمساحة إجمالية 5000 متر مربع. يشمل المشروع الأعمال الإنشائية والمعمارية والكهربائية والميكانيكية وأعمال التشطيبات.
+            
+            ثالثاً: شروط التأهيل
+            1. أن يكون المقاول مصنفاً في مجال المباني من الدرجة الأولى.
+            2. أن يكون لديه خبرة سابقة في تنفيذ مشاريع مماثلة لا تقل عن 3 مشاريع خلال الخمس سنوات الماضية.
+            3. أن يكون لديه سيولة مالية كافية لتنفيذ المشروع.
+            
+            رابعاً: الضمانات المطلوبة
+            1. ضمان ابتدائي: 2% من قيمة العطاء ساري المفعول لمدة 90 يوماً من تاريخ تقديم العطاء.
+            2. ضمان نهائي: 5% من قيمة العقد ساري المفعول حتى انتهاء فترة الضمان.
+            
+            خامساً: مدة التنفيذ
+            مدة تنفيذ المشروع 18 شهراً من تاريخ استلام الموقع.
+            
+            سادساً: غرامات التأخير
+            في حالة تأخر المقاول عن التنفيذ في الموعد المحدد، يتم تطبيق غرامة تأخير بنسبة 1% من قيمة العقد عن كل أسبوع تأخير بحد أقصى 10% من قيمة العقد.
+            
+            سابعاً: شروط الدفع
+            يتم سداد قيمة العقد على دفعات شهرية حسب نسبة الإنجاز، مع احتج��ز 10% من قيمة كل دفعة كضمان حسن التنفيذ.
+            
+            ثامناً: المواصفات الفنية
+            1. الأعمال الإنشائية:
+               - الخرسانة المسلحة: مقاومة لا تقل عن 300 كجم/سم²
+               - حديد التسليح: درجة 60
+            
+            2. الأعمال المعمارية:
+               - الواجهات: زجاج عاكس وحجر طبيعي
+               - الأرضيات: رخام للمداخل وبورسلين للمكاتب
+               - الأسقف: أسقف مستعارة من الجبس المزخرف
+            
+            3. الأعمال الكهربائية:
+               - نظام إنارة موفر للطاقة
+               - نظام إنذار وإطفاء حريق آلي
+               - نظام مراقبة بالكاميرات
+            
+            4. الأعمال الميكانيكية:
+               - نظام تكييف مركزي
+               - نظام تهوية متطور
+               - مصاعد عدد 3
+            
+            تاسعاً: معايير التقييم
+            1. السعر: 50%
+            2. الجودة الفنية: 30%
+            3. الخبرة السابقة: 15%
+            4. مدة التنفيذ: 5%
+            
+            عاشراً: تقديم العطاءات
+            يتم تقديم العطاءات في مظروفين منفصلين (فني ومالي) إلى إدارة المشتريات بوزارة المالية في موعد أقصاه الساعة 12 ظهراً من يوم 15/04/2024م.
+            """
+        else:
+            return """
+            محتوى الملف غير معروف. يرجى التأكد من نوع الملف وصيغته.
+            """
+    
+    def _comprehensive_analysis(self, contract_text, file_name):
+        """
+        تحليل شامل للعقد
+        
+        المعلمات:
+            contract_text (str): نص العقد
+            file_name (str): اسم الملف
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # محاكاة تحليل شامل للعقد
+        
+        # استخراج الأطراف
+        parties = self._extract_parties(contract_text)
+        
+        # استخراج قيمة العقد
+        contract_value = self._extract_contract_value(contract_text)
+        
+        # استخراج مدة التنفيذ
+        duration = self._extract_duration(contract_text)
+        
+        # استخراج الضمانات
+        guarantees = self._extract_guarantees(contract_text)
+        
+        # استخراج غرامات التأخير
+        penalties = self._extract_penalties(contract_text)
+        
+        # استخراج شروط الدفع
+        payment_terms = self._extract_payment_terms(contract_text)
+        
+        # استخراج فترة الضمان
+        warranty_period = self._extract_warranty_period(contract_text)
+        
+        # استخراج شروط فسخ العقد
+        termination_terms = self._extract_termination_terms(contract_text)
+        
+        # استخراج آلية تسوية النزاعات
+        dispute_resolution = self._extract_dispute_resolution(contract_text)
+        
+        # تحديد المخاطر
+        risks = self._identify_risks_in_text(contract_text)
+        
+        # اقتراح تحسينات
+        improvements = self._suggest_improvements_for_text(contract_text)
+        
+        # إعداد النتائج
+        results = {
+            "title": f"تحليل شامل - {file_name}",
+            "date": datetime.now().strftime("%Y-%m-%d"),
+            "summary": "هذا العقد يتعلق بإنشاء مبنى إداري لصالح وزارة المالية. يتضمن العقد شروطاً متعلقة بقيمة العقد، مدة التنفيذ، الدفعات، الضمانات، غرامات التأخير، فترة الضمان، فسخ العقد، وتسوية النزاعات.",
+            "key_points": [
+                f"قيمة العقد: {contract_value}",
+                f"مدة التنفيذ: {duration}",
+                f"الضمانات: {guarantees}",
+                f"غرامات التأخير: {penalties}",
+                f"شروط الدفع: {payment_terms}",
+                f"فترة الضمان: {warranty_period}"
+            ],
+            "entities": {
+                "الأطراف": parties,
+                "قيمة العقد": contract_value,
+                "مدة التنفيذ": duration,
+                "الضمانات": guarantees,
+                "غرامات التأخير": penalties,
+                "شروط الدفع": payment_terms,
+                "فترة الضمان": warranty_period,
+                "شروط فسخ العقد": termination_terms,
+                "آلية تسوية النزاعات": dispute_resolution
+            },
+            "risks": risks,
+            "improvements": improvements,
+            "recommendations": [
+                "مراجعة قيمة الضمان النهائي للتأكد من كفايتها",
+                "توضيح آلية احتساب نسبة الإنجاز للدفعات الشهرية",
+                "إضافة بند يتعلق بالتغييرات في نطاق العمل",
+                "توضيح حقوق الملكية الفكرية للتصاميم والمخططات",
+                "إضافة بند يتعلق بالقوة القاهرة"
+            ]
+        }
+        
+        return results
+    
+    def _quick_analysis(self, contract_text, file_name):
+        """
+        تحليل سريع للعقد
+        
+        المعلمات:
+            contract_text (str): نص العقد
+            file_name (str): اسم الملف
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # محاكاة تحليل سريع للعقد
+        
+        # استخراج الأطراف
+        parties = self._extract_parties(contract_text)
+        
+        # استخراج قيمة العقد
+        contract_value = self._extract_contract_value(contract_text)
+        
+        # استخراج مدة التنفيذ
+        duration = self._extract_duration(contract_text)
+        
+        # استخراج الضمانات
+        guarantees = self._extract_guarantees(contract_text)
+        
+        # إعداد النتائج
+        results = {
+            "title": f"تحليل سريع - {file_name}",
+            "date": datetime.now().strftime("%Y-%m-%d"),
+            "summary": "هذا العقد يتعلق بإنشاء مبنى إداري لصالح وزارة المالية.",
+            "key_points": [
+                f"قيمة العقد: {contract_value}",
+                f"مدة التنفيذ: {duration}",
+                f"الضمانات: {guarantees}"
+            ],
+            "entities": {
+                "الأطراف": parties,
+                "قيمة العقد": contract_value,
+                "مدة التنفيذ": duration,
+                "الضمانات": guarantees
+            },
+            "recommendations": [
+                "مراجعة قيمة الضمان النهائي للتأكد من كفايتها",
+                "توضيح آلية احتساب نسبة الإنجاز للدفعات الشهرية"
+            ]
+        }
+        
+        return results
+    
+    def _legal_analysis(self, contract_text, file_name):
+        """
+        تحليل قانوني للعقد
+        
+        المعلمات:
+            contract_text (str): نص العقد
+            file_name (str): اسم الملف
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # محاكاة تحليل قانوني للعقد
+        
+        # استخراج الأطراف
+        parties = self._extract_parties(contract_text)
+        
+        # استخراج الضمانات
+        guarantees = self._extract_guarantees(contract_text)
+        
+        # استخراج غرامات التأخير
+        penalties = self._extract_penalties(contract_text)
+        
+        # استخراج شروط فسخ العقد
+        termination_terms = self._extract_termination_terms(contract_text)
+        
+        # استخراج آلية تسوية النزاعات
+        dispute_resolution = self._extract_dispute_resolution(contract_text)
+        
+        # تحديد المخاطر القانونية
+        legal_risks = [
+            "عدم وضوح آلية تسوية النزاعات",
+            "عدم تحديد المحكمة المختصة",
+            "عدم وضوح شروط فسخ العقد",
+            "عدم وجود بند يتعلق بالقوة القاهرة",
+            "عدم وضوح حقوق الملكية الفكرية"
+        ]
+        
+        # إعداد النتائج
+        results = {
+            "title": f"تحليل قانوني - {file_name}",
+            "date": datetime.now().strftime("%Y-%m-%d"),
+            "summary": "هذا العقد يتضمن بعض الثغرات القانونية التي قد تؤدي إلى نزاعات مستقبلية.",
+            "key_points": [
+                f"الضمانات: {guarantees}",
+                f"غرامات التأخير: {penalties}",
+                f"شروط فسخ العقد: {termination_terms}",
+                f"آلية تسوية النزاعات: {dispute_resolution}"
+            ],
+            "entities": {
+                "الأطراف": parties,
+                "الضمانات": guarantees,
+                "غرامات التأخير": penalties,
+                "شروط فسخ العقد": termination_terms,
+                "آلية تسوية النزاعات": dispute_resolution
+            },
+            "legal_risks": legal_risks,
+            "recommendations": [
+                "توضيح آلية تسوية النزاعات وتحديد المحكمة المختصة",
+                "إضافة بند يتعلق بالقوة القاهرة",
+                "توضيح شروط فسخ العقد بشكل أكثر تفصيلاً",
+                "إضافة بند يتعلق بحقوق الملكية الفكرية",
+                "توضيح آلية تعديل العقد"
+            ]
+        }
+        
+        return results
+    
+    def _financial_analysis(self, contract_text, file_name):
+        """
+        تحليل مالي للعقد
+        
+        المعلمات:
+            contract_text (str): نص العقد
+            file_name (str): اسم الملف
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # محاكاة تحليل مالي للعقد
+        
+        # استخراج قيمة العقد
+        contract_value = self._extract_contract_value(contract_text)
+        
+        # استخراج شروط الدفع
+        payment_terms = self._extract_payment_terms(contract_text)
+        
+        # استخراج الضمانات
+        guarantees = self._extract_guarantees(contract_text)
+        
+        # استخراج غرامات التأخير
+        penalties = self._extract_penalties(contract_text)
+        
+        # تحليل التدفقات النقدية
+        cash_flow = [
+            {"month": 1, "income": 1250000, "expense": 1000000, "net": 250000},
+            {"month": 2, "income": 1250000, "expense": 1100000, "net": 150000},
+            {"month": 3, "income": 1250000, "expense": 1200000, "net": 50000},
+            {"month": 4, "income": 1250000, "expense": 1000000, "net": 250000},
+            {"month": 5, "income": 1250000, "expense": 900000, "net": 350000},
+            {"month": 6, "income": 1250000, "expense": 950000, "net": 300000}
+        ]
+        
+        # تحليل المخاطر المالية
+        financial_risks = [
+            "تأخر الدفعات",
+            "زيادة أسعار المواد",
+            "نقص السيولة",
+            "تغير أسعار العملات",
+            "زيادة تكاليف العمالة"
+        ]
+        
+        # إعداد النتائج
+        results = {
+            "title": f"تحليل مالي - {file_name}",
+            "date": datetime.now().strftime("%Y-%m-%d"),
+            "summary": f"هذا العقد بقيمة {contract_value} يتضمن شروط دفع شهرية حسب نسبة الإنجاز مع احتجاز 10% من قيمة كل دفعة كضمان حسن التنفيذ.",
+            "key_points": [
+                f"قيمة العقد: {contract_value}",
+                f"شروط الدفع: {payment_terms}",
+                f"الضمانات: {guarantees}",
+                f"غرامات التأخير: {penalties}"
+            ],
+            "entities": {
+                "قيمة العقد": contract_value,
+                "شروط الدفع": payment_terms,
+                "الضمانات": guarantees,
+                "غرامات التأخير": penalties
+            },
+            "cash_flow": cash_flow,
+            "financial_risks": financial_risks,
+            "recommendations": [
+                "توضيح آلية احتساب نسبة الإنجاز للدفعات الشهرية",
+                "إضافة بند يتعلق بتعديل قيمة العقد في حالة تغير أسعار المواد",
+                "تقليل نسبة احتجاز ضمان حسن التنفيذ",
+                "إضافة بند يتعلق بالدفعة المقدمة",
+                "توضيح آلية تسوية المستخلصات النهائية"
+            ]
+        }
+        
+        return results
+    
+    def _comprehensive_tender_analysis(self, tender_text, file_name):
+        """
+        تحليل شامل للمناقصة
+        
+        المعلمات:
+            tender_text (str): نص المناقصة
+            file_name (str): اسم الملف
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # محاكاة تحليل شامل للمناقصة
+        
+        # استخراج معلومات المناقصة
+        tender_info = self._extract_tender_info(tender_text)
+        
+        # استخراج وصف المشروع
+        project_description = self._extract_project_description(tender_text)
+        
+        # استخراج شروط التأهيل
+        qualification_conditions = self._extract_qualification_conditions(tender_text)
+        
+        # استخراج الضمانات المطلوبة
+        required_guarantees = self._extract_required_guarantees(tender_text)
+        
+        # استخراج مدة التنفيذ
+        duration = self._extract_duration(tender_text)
+        
+        # استخراج غرامات التأخير
+        penalties = self._extract_penalties(tender_text)
+        
+        # استخراج شروط الدفع
+        payment_terms = self._extract_payment_terms(tender_text)
+        
+        # استخراج المواصفات الفنية
+        technical_specifications = self._extract_technical_specifications(tender_text)
+        
+        # استخراج معايير التقييم
+        evaluation_criteria = self._extract_evaluation_criteria(tender_text)
+        
+        # تحليل المنافسة
+        competition_analysis = self._analyze_competition(tender_info)
+        
+        # تحليل المخاطر
+        risk_analysis = self._analyze_risks(tender_text)
+        
+        # تحليل الفرص
+        opportunity_analysis = self._analyze_opportunities(tender_text)
+        
+        # إعداد النتائج
+        results = {
+            "title": f"تحليل شامل - {file_name}",
+            "date": datetime.now().strftime("%Y-%m-%d"),
+            "summary": f"هذه المناقصة تتعلق بإنشاء مبنى إداري لصالح وزارة المالية. تتضمن المناقصة شروطاً متعلقة بالتأهيل، الضمانات، مدة التنفيذ، غرامات التأخير، شروط الدفع، المواصفات الفنية، ومعايير التقييم.",
+            "key_points": [
+                f"رقم المناقصة: {tender_info.get('رقم المناقصة', 'غير محدد')}",
+                f"الجهة المالكة: {tender_info.get('الجهة المالكة', 'غير محدد')}",
+                f"موقع المشروع: {tender_info.get('موقع المشروع', 'غير محدد')}",
+                f"تاريخ الطرح: {tender_info.get('تاريخ الطرح', 'غير محدد')}",
+                f"تاريخ الإقفال: {tender_info.get('تاريخ الإقفال', 'غير محدد')}",
+                f"مدة التنفيذ: {duration}",
+                f"الضمانات المطلوبة: {required_guarantees}"
+            ],
+            "entities": {
+                "معلومات المناقصة": tender_info,
+                "وصف المشروع": project_description,
+                "شروط التأهيل": qualification_conditions,
+                "الضمانات المطلوبة": required_guarantees,
+                "مدة التنفيذ": duration,
+                "غرامات التأخير": penalties,
+                "شروط الدفع": payment_terms,
+                "المواصفات الفنية": technical_specifications,
+                "معايير التقييم": evaluation_criteria
+            },
+            "competition_analysis": competition_analysis,
+            "risk_analysis": risk_analysis,
+            "opportunity_analysis": opportunity_analysis,
+            "recommendations": [
+                "تقديم عرض سعر تنافسي يقل بنسبة 5-10% عن الميزانية التقديرية",
+                "التركيز على الجوانب الفنية في العرض",
+                "إبراز الخبرات السابقة في مشاريع مماثلة",
+                "تقديم جدول زمني مفصل للتنفيذ",
+                "تقديم حلول مبتكرة لتقليل التكاليف وزيادة الجودة"
+            ]
+        }
+        
+        return results
+    
+    def _quick_tender_analysis(self, tender_text, file_name):
+        """
+        تحليل سريع للمناقصة
+        
+        المعلمات:
+            tender_text (str): نص المناقصة
+            file_name (str): اسم الملف
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # محاكاة تحليل سريع للمناقصة
+        
+        # استخراج معلومات المناقصة
+        tender_info = self._extract_tender_info(tender_text)
+        
+        # استخراج وصف المشروع
+        project_description = self._extract_project_description(tender_text)
+        
+        # استخراج مدة التنفيذ
+        duration = self._extract_duration(tender_text)
+        
+        # استخراج الضمانات المطلوبة
+        required_guarantees = self._extract_required_guarantees(tender_text)
+        
+        # إعداد النتائج
+        results = {
+            "title": f"تحليل سريع - {file_name}",
+            "date": datetime.now().strftime("%Y-%m-%d"),
+            "summary": f"هذه المناقصة تتعلق بإنشاء مبنى إداري لصالح وزارة المالية.",
+            "key_points": [
+                f"رقم المناقصة: {tender_info.get('رقم المناقصة', 'غير محدد')}",
+                f"الجهة المالكة: {tender_info.get('الجهة المالكة', 'غير محدد')}",
+                f"موقع المشروع: {tender_info.get('موقع المشروع', 'غير محدد')}",
+                f"تاريخ الإقفال: {tender_info.get('تاريخ الإقفال', 'غير محدد')}",
+                f"مدة التنفيذ: {duration}"
+            ],
+            "entities": {
+                "معلومات المناقصة": tender_info,
+                "وصف المشروع": project_description,
+                "مدة التنفيذ": duration,
+                "الضمانات المطلوبة": required_guarantees
+            },
+            "recommendations": [
+                "تقديم عرض سعر تنافسي",
+                "إبراز الخبرات السابقة في مشاريع مماثلة"
+            ]
+        }
+        
+        return results
+    
+    def _technical_tender_analysis(self, tender_text, file_name):
+        """
+        تحليل فني للمناقصة
+        
+        المعلمات:
+            tender_text (str): نص المناقصة
+            file_name (str): اسم الملف
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # محاكاة تحليل فني للمناقصة
+        
+        # استخراج وصف المشروع
+        project_description = self._extract_project_description(tender_text)
+        
+        # استخراج المواصفات الفنية
+        technical_specifications = self._extract_technical_specifications(tender_text)
+        
+        # استخراج مدة التنفيذ
+        duration = self._extract_duration(tender_text)
+        
+        # تحليل المتطلبات الفنية
+        technical_requirements_analysis = self._analyze_technical_requirements(technical_specifications)
+        
+        # تحليل المخاطر الفنية
+        technical_risks = self._analyze_technical_risks(technical_specifications)
+        
+        # إعداد النتائج
+        results = {
+            "title": f"تحليل فني - {file_name}",
+            "date": datetime.now().strftime("%Y-%m-%d"),
+            "summary": f"هذه المناقصة تتضمن متطلبات فنية متوسطة المستوى. المشروع يتكون من إنشاء مبنى إداري مكون من 5 طوابق بمساحة إجمالية 5000 متر مربع.",
+            "key_points": [
+                f"وصف المشروع: {project_description}",
+                f"مدة التنفيذ: {duration}",
+                "المواصفات الفنية تشمل الأعمال الإنشائية والمعمارية والكهربائية والميكانيكية"
+            ],
+            "entities": {
+                "وصف المشروع": project_description,
+                "المواصفات الفنية": technical_specifications,
+                "مدة التنفيذ": duration
+            },
+            "technical_requirements_analysis": technical_requirements_analysis,
+            "technical_risks": technical_risks,
+            "recommendations": [
+                "التركيز على الجوانب الفنية في العرض",
+                "تقديم حلول مبتكرة لتحسين الجودة",
+                "تقديم جدول زمني مفصل للتنفيذ",
+                "اقتراح بدائل فنية لتقليل التكاليف",
+                "تقديم خطة ضمان الجودة"
+            ]
+        }
+        
+        return results
+    
+    def _financial_tender_analysis(self, tender_text, file_name):
+        """
+        تحليل مالي للمناقصة
+        
+        المعلمات:
+            tender_text (str): نص المناقصة
+            file_name (str): اسم الملف
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # محاكاة تحليل مالي للمناقصة
+        
+        # استخراج معلومات المناقصة
+        tender_info = self._extract_tender_info(tender_text)
+        
+        # استخراج وصف المشروع
+        project_description = self._extract_project_description(tender_text)
+        
+        # استخراج الضمانات المطلوبة
+        required_guarantees = self._extract_required_guarantees(tender_text)
+        
+        # استخراج شروط الدفع
+        payment_terms = self._extract_payment_terms(tender_text)
+        
+        # استخراج غرامات التأخير
+        penalties = self._extract_penalties(tender_text)
+        
+        # تقدير التكاليف
+        cost_estimation = self._estimate_costs(project_description)
+        
+        # تحليل التدفقات النقدية
+        cash_flow = self._analyze_cash_flow(payment_terms, cost_estimation)
+        
+        # تحليل المخاطر المالية
+        financial_risks = self._analyze_financial_risks(tender_text)
+        
+        # إعداد النتائج
+        results = {
+            "title": f"تحليل مالي - {file_name}",
+            "date": datetime.now().strftime("%Y-%m-%d"),
+            "summary": f"هذه المناقصة تتطلب ضماناً ابتدائياً بنسبة 2% من قيمة العطاء وضماناً نهائياً بنسبة 5% من قيمة العقد. شروط الدفع هي دفعات شهرية حسب نسبة الإنجاز مع احتجاز 10% من قيمة كل دفعة.",
+            "key_points": [
+                f"الضمانات المطلوبة: {required_guarantees}",
+                f"شروط الدفع: {payment_terms}",
+                f"غرامات التأخير: {penalties}",
+                f"تقدير التكلفة الإجمالية: {cost_estimation.get('total_cost', 0):,} ريال"
+            ],
+            "entities": {
+                "معلومات المناقصة": tender_info,
+                "الضمانات المطلوبة": required_guarantees,
+                "شروط الدفع": payment_terms,
+                "غرامات التأخير": penalties
+            },
+            "cost_estimation": cost_estimation,
+            "cash_flow": cash_flow,
+            "financial_risks": financial_risks,
+            "recommendations": [
+                "تقديم عرض سعر يقل بنسبة 5-10% عن الميزانية التقديرية",
+                "طلب دفعة مقدمة لتحسين التدفق النقدي",
+                "تقليل نسبة احتجاز ضمان حسن التنفيذ",
+                "تقديم بدائل لتقليل التكاليف",
+                "وضع خطة للتعامل مع المخاطر المالية"
+            ]
+        }
+        
+        return results
+    
+    def _simulate_dwg_analysis(self, file_path):
+        """
+        محاكاة تحليل ملف DWG
+        
+        المعلمات:
+            file_path (str): مسار ملف DWG
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # محاكاة تحليل ملف DWG
+        results = {
+            "file_name": os.path.basename(file_path),
+            "file_size": f"{np.random.randint(1, 10)} MB",
+            "elements_count": np.random.randint(100, 1000),
+            "layers_count": np.random.randint(5, 20),
+            "dimensions": {
+                "width": f"{np.random.randint(10, 100)} م",
+                "height": f"{np.random.randint(10, 100)} م",
+                "area": f"{np.random.randint(100, 10000)} م²"
+            },
+            "elements": {
+                "walls": np.random.randint(10, 100),
+                "doors": np.random.randint(5, 50),
+                "windows": np.random.randint(5, 50),
+                "columns": np.random.randint(5, 50),
+                "stairs": np.random.randint(1, 10)
+            },
+            "materials": [
+                {"name": "خرسانة", "volume": f"{np.random.randint(10, 1000)} م³"},
+                {"name": "حديد", "weight": f"{np.random.randint(1, 100)} طن"},
+                {"name": "طابوق", "count": f"{np.random.randint(1000, 10000)} قطعة"},
+                {"name": "زجاج", "area": f"{np.random.randint(10, 1000)} م²"},
+                {"name": "خشب", "volume": f"{np.random.randint(1, 50)} م³"}
+            ],
+            "cost_estimate": {
+                "materials": np.random.randint(100000, 1000000),
+                "labor": np.random.randint(50000, 500000),
+                "equipment": np.random.randint(10000, 100000),
+                "total": np.random.randint(200000, 2000000)
+            },
+            "recommendations": [
+                "يمكن تقليل تكلفة المواد باستخدام بدائل أقل تكلفة",
+                "يمكن تحسين كفاءة استخدام المساحة",
+                "يمكن تقليل عدد الأعمدة لتوفير التكلفة",
+                "يمكن تحسين تصميم السلالم لزيادة السلامة",
+                "يمكن تحسين توزيع النوافذ لزيادة الإضاءة الطبيعية"
+            ]
+        }
+        
+        return results
+    
+    def _compare_documents(self, text1, text2, file_name1, file_name2):
+        """
+        مقارنة مستندين
+        
+        المعلمات:
+            text1 (str): نص المستند الأول
+            text2 (str): نص المستند الثاني
+            file_name1 (str): اسم الملف الأول
+            file_name2 (str): اسم الملف الثاني
+            
+        العوائد:
+            dict: نتائج المقارنة
+        """
+        # محاكاة مقارنة مستندين
+        
+        # تحليل المستند الأول
+        doc1_analysis = self._quick_analysis(text1, file_name1)
+        
+        # تحليل المستند الثاني
+        doc2_analysis = self._quick_analysis(text2, file_name2)
+        
+        # تحديد أوجه التشابه
+        similarities = [
+            "كلا المستندين يتع��قان بمشاريع إنشائية",
+            "كلا المستندين يتضمنان شروطاً متعلقة بالضمانات",
+            "كلا المستندين يتضمنان شروطاً متعلقة بغرامات التأخير",
+            "كلا المستندين يتضمنان شروطاً متعلقة بشروط الدفع"
+        ]
+        
+        # تحديد أوجه الاختلاف
+        differences = [
+            "المستند الأول يتعلق بعقد إنشاء، بينما المستند الثاني يتعلق بمناقصة",
+            "قيمة الضمان النهائي في المستند الأول 5%، بينما في المستند الثاني 10%",
+            "مدة التنفيذ في المستند الأول 18 شهراً، بينما في المستند الثاني 24 شهراً",
+            "شروط الدفع في المستند الأول تتضمن دفعة مقدمة، بينما في المستند الثاني لا توجد دفعة مقدمة"
+        ]
+        
+        # إعداد النتائج
+        results = {
+            "title": f"مقارنة بين {file_name1} و {file_name2}",
+            "date": datetime.now().strftime("%Y-%m-%d"),
+            "summary": "هذه المقارنة تظهر أوجه التشابه والاختلاف بين المستندين. يتشابه المستندان في كونهما يتعلقان بمشاريع إنشائية ويتضمنان شروطاً متعلقة بالضمانات وغرامات التأخير وشروط الدفع. ومع ذلك، هناك اختلافات في نوع المستند وقيمة الضمان النهائي ومدة التنفيذ وشروط الدفع.",
+            "document1": {
+                "title": doc1_analysis.get("title", ""),
+                "summary": doc1_analysis.get("summary", ""),
+                "key_points": doc1_analysis.get("key_points", [])
+            },
+            "document2": {
+                "title": doc2_analysis.get("title", ""),
+                "summary": doc2_analysis.get("summary", ""),
+                "key_points": doc2_analysis.get("key_points", [])
+            },
+            "similarities": similarities,
+            "differences": differences,
+            "recommendations": [
+                "مراجعة الاختلافات في قيمة الضمان النهائي",
+                "مراجعة الاختلافات في مدة التنفيذ",
+                "مراجعة الاختلافات في شروط الدفع",
+                "توحيد الشروط في المستندين إذا كانا يتعلقان بنفس المشروع"
+            ]
+        }
+        
+        return results
+    
+    def _extract_key_terms_from_text(self, text):
+        """
+        استخراج الشروط الرئيسية من النص
+        
+        المعلمات:
+            text (str): نص العقد
+            
+        العوائد:
+            dict: الشروط الرئيسية المستخرجة
+        """
+        # محاكاة استخراج الشروط الرئيسية
+        key_terms = {
+            "الأطراف": self._extract_parties(text),
+            "قيمة العقد": self._extract_contract_value(text),
+            "مدة التنفيذ": self._extract_duration(text),
+            "الضمانات": self._extract_guarantees(text),
+            "غرامات التأخير": self._extract_penalties(text),
+            "شروط الدفع": self._extract_payment_terms(text),
+            "فترة الضمان": self._extract_warranty_period(text),
+            "شروط فسخ العقد": self._extract_termination_terms(text),
+            "آلية تسوية النزاعات": self._extract_dispute_resolution(text)
+        }
+        
+        return key_terms
+    
+    def _identify_risks_in_text(self, text):
+        """
+        تحديد المخاطر في النص
+        
+        المعلمات:
+            text (str): نص العقد
+            
+        العوائد:
+            list: المخاطر المحددة
+        """
+        # محاكاة تحديد المخاطر
+        risks = [
+            {"risk": "ارتفاع أسعار المواد", "probability": "متوسطة", "impact": "عالي", "mitigation": "تثبيت أسعار المواد الرئيسية مع الموردين"},
+            {"risk": "تأخر التنفيذ", "probability": "متوسطة", "impact": "عالي", "mitigation": "وضع خطة تنفيذ مفصلة مع هوامش زمنية"},
+            {"risk": "نقص العمالة الماهرة", "probability": "منخفضة", "impact": "متوسط", "mitigation": "التعاقد المسبق مع مقاولي الباطن"},
+            {"risk": "تغيير نطاق العمل", "probability": "متوسطة", "impact": "عالي", "mitigation": "توثيق نطاق العمل بدقة وتحديد إجراءات التغيير"},
+            {"risk": "مشاكل في التربة", "probability": "منخفضة", "impact": "عالي", "mitigation": "إجراء فحوصات شاملة للتربة قبل البدء"}
+        ]
+        
+        return risks
+    
+    def _suggest_improvements_for_text(self, text):
+        """
+        اقتراح تحسينات للنص
+        
+        المعلمات:
+            text (str): نص العقد
+            
+        العوائد:
+            list: التحسينات المقترحة
+        """
+        # محاكاة اقتراح تحسينات
+        improvements = [
+            "إضافة بند يتعلق بالقوة القاهرة",
+            "توضيح آلية تسوية النزاعات وتحديد المحكمة المختصة",
+            "إضافة بند يتعلق بحقوق الملكية الفكرية",
+            "توضيح آلية تعديل العقد",
+            "إضافة بند يتعلق بالتأمين على المشروع",
+            "توضيح آلية احتساب نسبة الإنجاز للدفعات الشهرية",
+            "إضافة بند يتعلق بالتغييرات في نطاق العمل",
+            "توضيح مسؤوليات كل طرف بشكل أكثر تفصيلاً"
+        ]
+        
+        return improvements
+    
+    def _extract_parties(self, text):
+        """استخراج الأطراف من النص"""
+        if "الطرف الأول: وزارة المالية" in text:
+            return {
+                "الطرف الأول": "وزارة المالية",
+                "الطرف الثاني": "شركة الإنشاءات المتطورة"
+            }
+        elif "الجهة المالكة: وزارة المالية" in text:
+            return {
+                "الجهة المالكة": "وزارة المالية"
+            }
+        else:
+            return {
+                "الطرف الأول": "غير محدد",
+                "الطرف الثاني": "غير محدد"
+            }
+    
+    def _extract_contract_value(self, text):
+        """استخراج قيمة العقد من النص"""
+        if "قيمة العقد الإجمالية هي 25,000,000 ريال" in text:
+            return "25,000,000 ريال"
+        else:
+            return "غير محدد"
+    
+    def _extract_duration(self, text):
+        """استخراج مدة التنفيذ من النص"""
+        if "مدة تنفيذ المشروع 18 شهراً" in text:
+            return "18 شهراً"
+        else:
+            return "غير محدد"
+    
+    def _extract_guarantees(self, text):
+        """استخراج الضمانات من النص"""
+        if "ضماناً نهائياً بنسبة 5% من قيمة العقد" in text:
+            return "ضمان نهائي بنسبة 5% من قيمة العقد"
+        elif "ضمان ابتدائي: 2% من قيمة العطاء" in text:
+            return "ضمان ابتدائي بنسبة 2% من قيمة العطاء، وضمان نهائي بنسبة 5% من قيمة العقد"
+        else:
+            return "غير محدد"
+    
+    def _extract_penalties(self, text):
+        """استخراج غرامات التأخير من النص"""
+        if "غرامة تأخير بنسبة 1% من قيمة العقد عن كل أسبوع تأخير بحد أقصى 10% من قيمة العقد" in text:
+            return "1% من قيمة العقد عن كل أسبوع تأخير بحد أقصى 10% من قيمة العقد"
+        else:
+            return "غير محدد"
+    
+    def _extract_payment_terms(self, text):
+        """استخراج شروط الدفع من النص"""
+        if "دفعات شهرية حسب نسبة الإنجاز، مع احتجاز 10% من قيمة كل دفعة كضمان حسن التنفيذ" in text:
+            return "دفعات شهرية حسب نسبة الإنجاز، مع احتجاز 10% من قيمة كل دفعة كضمان حسن التنفيذ"
+        else:
+            return "غير محدد"
+    
+    def _extract_warranty_period(self, text):
+        """استخراج فترة الضمان من النص"""
+        if "فترة ضمان المشروع سنة واحدة من تاريخ الاستلام الابتدائي" in text:
+            return "سنة واحدة من تاريخ الاستلام الابتدائي"
+        else:
+            return "غير محدد"
+    
+    def _extract_termination_terms(self, text):
+        """استخراج شروط فسخ العقد من النص"""
+        if "يحق للطرف الأول فسخ العقد في حالة إخلال الطرف الثاني بالتزاماته التعاقدية بعد إنذاره كتابياً" in text:
+            return "يحق للطرف الأول فسخ العقد في حالة إخلال الطرف الثاني بالتزاماته التعاقدية بعد إنذاره كتابياً"
+        else:
+            return "غير محدد"
+    
+    def _extract_dispute_resolution(self, text):
+        """استخراج آلية تسوية النزاعات من النص"""
+        if "في حالة نشوء أي نزاع بين الطرفين، يتم حله ودياً، وفي حالة تعذر ذلك يتم اللجوء إلى التحكيم" in text:
+            return "يتم حل النزاعات ودياً، وفي حالة تعذر ذلك يتم اللجوء إلى التحكيم وفقاً لأنظمة المملكة العربية السعودية"
+        else:
+            return "غير محدد"
+    
+    def _extract_tender_info(self, text):
+        """استخراج معلومات المناقصة من النص"""
+        tender_info = {}
+        
+        if "رقم المناقصة: T-2024-001" in text:
+            tender_info["رقم المناقصة"] = "T-2024-001"
+        
+        if "الجهة المالكة: وزارة المالية" in text:
+            tender_info["الجهة المالكة"] = "وزارة المالية"
+        
+        if "موقع المشروع: الرياض - حي العليا" in text:
+            tender_info["موقع المشروع"] = "الرياض - حي العليا"
+        
+        if "تاريخ الطرح: 01/03/2024م" in text:
+            tender_info["تاريخ الطرح"] = "01/03/2024م"
+        
+        if "تاريخ الإقفال: 15/04/2024م" in text:
+            tender_info["تاريخ الإقفال"] = "15/04/2024م"
+        
+        return tender_info
+    
+    def _extract_project_description(self, text):
+        """استخراج وصف المشروع من النص"""
+        if "يتكون المشروع من إنشاء مبنى إداري مكون من 5 طوابق بمساحة إجمالية 5000 متر مربع" in text:
+            return "إنشاء مبنى إداري مكون من 5 طوابق بمساحة إجمالية 5000 متر مربع. يشمل المشروع الأعمال الإنشائية والمعمارية والكهربائية والميكانيكية وأعمال التشطيبات."
+        else:
+            return "غير محدد"
+    
+    def _extract_qualification_conditions(self, text):
+        """استخراج شروط التأهيل من النص"""
+        if "أن يكون المقاول مصنفاً في مجال المباني من الدرجة الأولى" in text:
+            return [
+                "أن يكون المقاول مصنفاً في مجال المباني من الدرجة الأولى",
+                "أن يكون لديه خبرة سابقة في تنفيذ مشاريع مماثلة لا تقل عن 3 مشاريع خلال الخمس سنوات الماضية",
+                "أن يكون لديه سيولة مالية كافية لتنفيذ المشروع"
+            ]
+        else:
+            return ["غير محدد"]
+    
+    def _extract_required_guarantees(self, text):
+        """استخراج الضمانات المطلوبة من النص"""
+        if "ضمان ابتدائي: 2% من قيمة العطاء" in text:
+            return [
+                "ضمان ابتدائي: 2% من قيمة العطاء ساري المفعول لمدة 90 يوماً من تاريخ تقديم العطاء",
+                "ضمان نهائي: 5% من قيمة العقد ساري المفعول حتى انتهاء فترة الضمان"
+            ]
+        else:
+            return ["غير محدد"]
+    
+    def _extract_technical_specifications(self, text):
+        """استخراج المواصفات الفنية من النص"""
+        if "الأعمال الإنشائية:" in text:
+            return {
+                "الأعمال الإنشائية": [
+                    "الخرسانة المسلحة: مقاومة لا تقل عن 300 كجم/سم²",
+                    "حديد التسليح: درجة 60"
+                ],
+                "الأعمال المعمارية": [
+                    "الواجهات: زجاج عاكس وحجر طبيعي",
+                    "الأرضيات: رخام للمداخل وبورسلين للمكاتب",
+                    "الأسقف: أسقف مستعارة من الجبس المزخرف"
+                ],
+                "الأعمال الكهربائية": [
+                    "نظام إنارة موفر للطاقة",
+                    "نظام إنذار وإطفاء حريق آلي",
+                    "نظام مراقبة بالكاميرات"
+                ],
+                "الأعمال الميكانيكية": [
+                    "نظام تكييف مركزي",
+                    "نظام تهوية متطور",
+                    "مصاعد عدد 3"
+                ]
+            }
+        else:
+            return {"غير محدد": ["غير محدد"]}
+    
+    def _extract_evaluation_criteria(self, text):
+        """استخراج معايير التقييم من النص"""
+        if "السعر: 50%" in text:
+            return {
+                "السعر": "50%",
+                "الجودة الفنية": "30%",
+                "الخبرة السابقة": "15%",
+                "مدة التنفيذ": "5%"
+            }
+        else:
+            return {"غير محدد": "غير محدد"}
+    
+    def _analyze_competition(self, tender_info):
+        """تحليل المنافسة"""
+        return {
+            "expected_competitors": [
+                {"name": "شركة الإنشاءات المتطورة", "strength": "خبرة طويلة في مشاريع مماثلة", "weakness": "أسعار مرتفعة", "win_probability": 30},
+                {"name": "شركة البناء الحديث", "strength": "أسعار تنافسية", "weakness": "خبرة محدودة", "win_probability": 25},
+                {"name": "شركة التطوير العمراني", "strength": "جودة عالية", "weakness": "بطء في التنفيذ", "win_probability": 20}
+            ],
+            "competitive_advantages": [
+                "خبرة في مشاريع مماثلة",
+                "فريق فني متميز",
+                "علاقات جيدة مع الموردين",
+                "تقنيات حديثة في التنفيذ"
+            ],
+            "competitive_disadvantages": [
+                "محدودية الموارد المالية",
+                "قلة الخبرة في بعض الجوانب الفنية"
+            ]
+        }
+    
+    def _analyze_risks(self, text):
+        """تحليل المخاطر"""
+        return [
+            {"risk": "ارتفاع أسعار المواد", "probability": "متوسطة", "impact": "عالي", "mitigation": "تثبيت أسعار المواد الرئيسية مع الموردين"},
+            {"risk": "تأخر التنفيذ", "probability": "متوسطة", "impact": "عالي", "mitigation": "وضع خطة تنفيذ مفصلة مع هوامش زمنية"},
+            {"risk": "نقص العمالة الماهرة", "probability": "منخفضة", "impact": "متوسط", "mitigation": "التعاقد المسبق مع مقاولي الباطن"},
+            {"risk": "تغيير نطاق العمل", "probability": "متوسطة", "impact": "عالي", "mitigation": "توثيق نطاق العمل بدقة وتحديد إجراءات التغيير"},
+            {"risk": "مشاكل في التربة", "probability": "منخفضة", "impact": "عالي", "mitigation": "إجراء فحوصات شاملة للتربة قبل البدء"}
+        ]
+    
+    def _analyze_opportunities(self, text):
+        """تحليل الفرص"""
+        return [
+            {"opportunity": "تقديم حلول مبتكرة لتقليل التكاليف", "benefit": "زيادة هامش الربح", "implementation": "استخدام تقنيات حديثة في التنفيذ"},
+            {"opportunity": "تقديم جدول زمني أقصر من المطلوب", "benefit": "زيادة فرص الفوز", "implementation": "استخدام فرق عمل متعددة"},
+            {"opportunity": "تقديم خدمات إضافية", "benefit": "تعزيز العلاقة مع العميل", "implementation": "تقديم خدمات الصيانة بعد انتهاء فترة الضمان"},
+            {"opportunity": "استخدام مواد صديقة للبيئة", "benefit": "تحسين السمعة", "implementation": "استخدام مواد معتمدة من هيئات البيئة"},
+            {"opportunity": "تطوير شراكات مع موردين", "benefit": "تقليل التكاليف", "implementation": "توقيع اتفاقيات طويلة الأمد مع الموردين"}
+        ]
+    
+    def _analyze_technical_requirements(self, technical_specifications):
+        """تحليل المتطلبات الفنية"""
+        return {
+            "complexity_level": "متوسط",
+            "special_requirements": [
+                "نظام إنارة موفر للطاقة",
+                "نظام إنذار وإطفاء حريق آلي",
+                "نظام تكييف مركزي"
+            ],
+            "technical_challenges": [
+                "تنفيذ الواجهات الزجاجية بالمواصفات المطلوبة",
+                "تركيب نظام التكييف المركزي",
+                "تنفيذ أعمال التشطيبات بالجودة المطلوبة"
+            ],
+            "required_expertise": [
+                "خبرة في تنفيذ المباني الإدارية",
+                "خبرة في تركيب أنظمة التكييف المركزي",
+                "خبرة في تنفيذ الواجهات الزجاجية"
+            ]
+        }
+    
+    def _analyze_technical_risks(self, technical_specifications):
+        """تحليل المخاطر الفنية"""
+        return [
+            {"risk": "عدم توفر المواد بالمواصفات المطلوبة", "probability": "منخفضة", "impact": "عالي", "mitigation": "التعاقد الم��بق مع الموردين"},
+            {"risk": "صعوبة تنفيذ الواجهات الزجاجية", "probability": "متوسطة", "impact": "متوسط", "mitigation": "الاستعانة بمقاول باطن متخصص"},
+            {"risk": "مشاكل في تركيب نظام التكييف المركزي", "probability": "منخفضة", "impact": "عالي", "mitigation": "الاستعانة بخبراء في تركيب أنظمة التكييف"},
+            {"risk": "عدم مطابقة التشطيبات للمواصفات", "probability": "متوسطة", "impact": "متوسط", "mitigation": "تطبيق نظام ضبط الجودة"},
+            {"risk": "تأخر توريد المواد", "probability": "متوسطة", "impact": "عالي", "mitigation": "وضع خطة توريد مفصلة مع هوامش زمنية"}
+        ]
+    
+    def _estimate_costs(self, project_description):
+        """تقدير التكاليف"""
+        return {
+            "total_cost": 25000000,
+            "cost_breakdown": [
+                {"category": "الأعمال الإنشائية", "amount": 10000000, "percentage": 40},
+                {"category": "الأعمال المعمارية", "amount": 6250000, "percentage": 25},
+                {"category": "الأعمال الكهربائية", "amount": 3750000, "percentage": 15},
+                {"category": "الأعمال الميكانيكية", "amount": 3750000, "percentage": 15},
+                {"category": "أعمال الموقع", "amount": 1250000, "percentage": 5}
+            ],
+            "cost_per_sqm": 5000,
+            "cost_saving_opportunities": [
+                {"item": "استخدام مواد بديلة", "potential_saving": 1250000},
+                {"item": "تحسين إنتاجية العمالة", "potential_saving": 750000},
+                {"item": "تأجير المعدات بدلاً من شرائها", "potential_saving": 500000}
+            ]
+        }
+    
+    def _analyze_cash_flow(self, payment_terms, cost_estimation):
+        """تحليل التدفقات النقدية"""
+        return [
+            {"month": 1, "income": 0, "expense": 2500000, "net": -2500000, "cumulative": -2500000},
+            {"month": 2, "income": 1125000, "expense": 2000000, "net": -875000, "cumulative": -3375000},
+            {"month": 3, "income": 1125000, "expense": 1500000, "net": -375000, "cumulative": -3750000},
+            {"month": 4, "income": 1125000, "expense": 1500000, "net": -375000, "cumulative": -4125000},
+            {"month": 5, "income": 1125000, "expense": 1500000, "net": -375000, "cumulative": -4500000},
+            {"month": 6, "income": 1125000, "expense": 1500000, "net": -375000, "cumulative": -4875000}
+        ]
+    
+    def _analyze_financial_risks(self, text):
+        """تحليل المخاطر المالية"""
+        return [
+            {"risk": "تأخر الدفعات", "probability": "متوسطة", "impact": "عالي", "mitigation": "وضع شروط واضحة للدفعات في العقد"},
+            {"risk": "زيادة أسعار المواد", "probability": "عالية", "impact": "عالي", "mitigation": "تثبيت أسعار المواد الرئيسية مع الموردين"},
+            {"risk": "نقص السيولة", "probability": "متوسطة", "impact": "عالي", "mitigation": "الحصول على تسهيلات بنكية"},
+            {"risk": "تغير أسعار العملات", "probability": "منخفضة", "impact": "متوسط", "mitigation": "استخدام عقود التحوط"},
+            {"risk": "زيادة تكاليف العمالة", "probability": "متوسطة", "impact": "متوسط", "mitigation": "التعاقد مع مقاولي الباطن بأسعار ثابتة"}
+        ]

modules/ai_assistant/data_integration.py

@@ -0,0 +1,577 @@
+"""
+وحدة تكامل البيانات مع الذكاء الاصطناعي
+
+هذا الملف يحتوي على الفئات والدوال اللازمة لتكامل وحدة تحليل البيانات مع وحدة الذكاء الاصطناعي.
+"""
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime
+import json
+import os
+import sys
+from pathlib import Path
+
+# إضافة المسار للوصول إلى وحدة تحليل البيانات
+current_dir = os.path.dirname(os.path.abspath(__file__))
+parent_dir = os.path.dirname(os.path.dirname(current_dir))
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+
+# محاولة استيراد وحدة تحليل البيانات
+try:
+    from modules.data_analysis.data_analysis_app import DataAnalysisApp
+except ImportError:
+    # تعريف فئة بديلة في حالة فشل الاستيراد
+    class DataAnalysisApp:
+        def __init__(self):
+            pass
+        
+        def run(self):
+            pass
+
+class DataAIIntegration:
+    """فئة تكامل البيانات مع الذكاء الاصطناعي"""
+    
+    def __init__(self):
+        """تهيئة فئة تكامل البيانات مع الذكاء الاصطناعي"""
+        self.data_analysis_app = DataAnalysisApp()
+    
+    def analyze_tender_data(self, tender_data):
+        """
+        تحليل بيانات المناقصة باستخدام الذكاء الاصطناعي
+        
+        المعلمات:
+            tender_data (dict): بيانات المناقصة
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # تحويل البيانات إلى DataFrame
+        if isinstance(tender_data, dict):
+            df = pd.DataFrame([tender_data])
+        elif isinstance(tender_data, list):
+            df = pd.DataFrame(tender_data)
+        else:
+            df = tender_data
+        
+        # تحليل البيانات
+        results = {
+            'summary': self._generate_summary(df),
+            'recommendations': self._generate_recommendations(df),
+            'risk_analysis': self._analyze_risks(df),
+            'cost_analysis': self._analyze_costs(df),
+            'competitive_analysis': self._analyze_competition(df)
+        }
+        
+        return results
+    
+    def analyze_historical_data(self, project_type=None, location=None, time_period=None):
+        """
+        تحليل البيانات التاريخية للمناقصات
+        
+        المعلمات:
+            project_type (str): نوع المشروع (اختياري)
+            location (str): الموقع (اختياري)
+            time_period (str): الفترة الزمنية (اختياري)
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # الحصول على البيانات التاريخية (محاكاة)
+        historical_data = self._get_historical_data()
+        
+        # تطبيق التصفية إذا تم تحديدها
+        filtered_data = historical_data.copy()
+        
+        if project_type:
+            filtered_data = filtered_data[filtered_data['نوع المشروع'] == project_type]
+        
+        if location:
+            filtered_data = filtered_data[filtered_data['الموقع'] == location]
+        
+        if time_period:
+            # تنفيذ تصفية الفترة الزمنية (محاكاة)
+            pass
+        
+        # تحليل البيانات
+        results = {
+            'win_rate': self._calculate_win_rate(filtered_data),
+            'avg_profit_margin': self._calculate_avg_profit_margin(filtered_data),
+            'price_trends': self._analyze_price_trends(filtered_data),
+            'success_factors': self._identify_success_factors(filtered_data),
+            'visualizations': self._generate_visualizations(filtered_data)
+        }
+        
+        return results
+    
+    def predict_tender_success(self, tender_data):
+        """
+        التنبؤ بفرص نجاح المناقصة
+        
+        المعلمات:
+            tender_data (dict): بيانات المناقصة
+            
+        العوائد:
+            dict: نتائج التنبؤ
+        """
+        # تحويل البيانات إلى DataFrame
+        if isinstance(tender_data, dict):
+            df = pd.DataFrame([tender_data])
+        elif isinstance(tender_data, list):
+            df = pd.DataFrame(tender_data)
+        else:
+            df = tender_data
+        
+        # تنفيذ التنبؤ (محاكاة)
+        success_probability = np.random.uniform(0, 100)
+        
+        # تحديد العوامل المؤثرة (محاكاة)
+        factors = [
+            {'name': 'السعر التنافسي', 'impact': np.random.uniform(0, 1), 'direction': 'إيجابي' if np.random.random() > 0.5 else 'سلبي'},
+            {'name': 'الخبرة السابقة', 'impact': np.random.uniform(0, 1), 'direction': 'إيجابي' if np.random.random() > 0.5 else 'سلبي'},
+            {'name': 'الجودة الفنية', 'impact': np.random.uniform(0, 1), 'direction': 'إيجابي' if np.random.random() > 0.5 else 'سلبي'},
+            {'name': 'المدة الزمنية', 'impact': np.random.uniform(0, 1), 'direction': 'إيجابي' if np.random.random() > 0.5 else 'سلبي'},
+            {'name': 'المنافسة', 'impact': np.random.uniform(0, 1), 'direction': 'إيجابي' if np.random.random() > 0.5 else 'سلبي'}
+        ]
+        
+        # ترتيب العوامل حسب التأثير
+        factors = sorted(factors, key=lambda x: x['impact'], reverse=True)
+        
+        # إعداد النتائج
+        results = {
+            'success_probability': success_probability,
+            'confidence': np.random.uniform(70, 95),
+            'factors': factors,
+            'recommendations': self._generate_success_recommendations(factors)
+        }
+        
+        return results
+    
+    def optimize_pricing(self, tender_data, competitors_data=None):
+        """
+        تحسين التسعير للمناقصة
+        
+        المعلمات:
+            tender_data (dict): بيانات المناقصة
+            competitors_data (list): بيانات المنافسين (اختياري)
+            
+        العوائد:
+            dict: نتائج التحسين
+        """
+        # تحويل البيانات إلى DataFrame
+        if isinstance(tender_data, dict):
+            df = pd.DataFrame([tender_data])
+        elif isinstance(tender_data, list):
+            df = pd.DataFrame(tender_data)
+        else:
+            df = tender_data
+        
+        # تحليل بيانات المنافسين إذا كانت متوفرة
+        if competitors_data:
+            competitors_df = pd.DataFrame(competitors_data)
+        else:
+            # استخدام بيانات افتراضية للمنافسين
+            competitors_df = self._get_competitors_data()
+        
+        # تنفيذ تحسين التسعير (محاكاة)
+        base_price = float(df['الميزانية التقديرية'].iloc[0]) if 'الميزانية التقديرية' in df.columns else 10000000
+        
+        # حساب نطاق السعر المقترح
+        min_price = base_price * 0.85
+        optimal_price = base_price * 0.92
+        max_price = base_price * 0.98
+        
+        # تحليل حساسية السعر
+        price_sensitivity = []
+        for price_factor in np.linspace(0.8, 1.1, 7):
+            price = base_price * price_factor
+            win_probability = max(0, min(100, 100 - (price_factor - 0.9) * 200))
+            profit = price - (base_price * 0.75)
+            expected_value = win_probability / 100 * profit
+            
+            price_sensitivity.append({
+                'price_factor': price_factor,
+                'price': price,
+                'win_probability': win_probability,
+                'profit': profit,
+                'expected_value': expected_value
+            })
+        
+        # إعداد النتائج
+        results = {
+            'min_price': min_price,
+            'optimal_price': optimal_price,
+            'max_price': max_price,
+            'price_sensitivity': price_sensitivity,
+            'market_position': self._analyze_market_position(optimal_price, competitors_df),
+            'recommendations': self._generate_pricing_recommendations(optimal_price, price_sensitivity)
+        }
+        
+        return results
+    
+    def analyze_dwg_files(self, file_path):
+        """
+        تحليل ملفات DWG باستخدام الذكاء الاصطناعي
+        
+        المعلمات:
+            file_path (str): مسار ملف DWG
+            
+        العوائد:
+            dict: نتائج التحليل
+        """
+        # محاكاة تحليل ملف DWG
+        results = {
+            'file_name': os.path.basename(file_path),
+            'file_size': f"{np.random.randint(1, 10)} MB",
+            'elements_count': np.random.randint(100, 1000),
+            'layers_count': np.random.randint(5, 20),
+            'dimensions': {
+                'width': f"{np.random.randint(10, 100)} م",
+                'height': f"{np.random.randint(10, 100)} م",
+                'area': f"{np.random.randint(100, 10000)} م²"
+            },
+            'elements': {
+                'walls': np.random.randint(10, 100),
+                'doors': np.random.randint(5, 50),
+                'windows': np.random.randint(5, 50),
+                'columns': np.random.randint(5, 50),
+                'stairs': np.random.randint(1, 10)
+            },
+            'materials': [
+                {'name': 'خرسانة', 'volume': f"{np.random.randint(10, 1000)} م³"},
+                {'name': 'حديد', 'weight': f"{np.random.randint(1, 100)} طن"},
+                {'name': 'طابوق', 'count': f"{np.random.randint(1000, 10000)} قطعة"},
+                {'name': 'زجاج', 'area': f"{np.random.randint(10, 1000)} م²"},
+                {'name': 'خشب', 'volume': f"{np.random.randint(1, 50)} م³"}
+            ],
+            'cost_estimate': {
+                'materials': np.random.randint(100000, 1000000),
+                'labor': np.random.randint(50000, 500000),
+                'equipment': np.random.randint(10000, 100000),
+                'total': np.random.randint(200000, 2000000)
+            },
+            'recommendations': [
+                'يمكن تقليل تكلفة المواد باستخدام بدائل أقل تكلفة',
+                'يمكن تحسين كفاءة استخدام المساحة',
+                'يمكن تقليل عدد الأعمدة لتوفير التكلفة',
+                'يمكن تحسين تصميم السلالم لزيادة السلامة',
+                'يمكن تحسين توزيع النوافذ لزيادة الإضاءة الطبيعية'
+            ]
+        }
+        
+        return results
+    
+    def integrate_with_ai_assistant(self, ai_assistant):
+        """
+        تكامل وحدة تحليل البيانات مع وحدة الذكاء الاصطناعي
+        
+        المعلمات:
+            ai_assistant: كائن وحدة الذكاء الاصطناعي
+            
+        العوائد:
+            bool: نجاح التكامل
+        """
+        try:
+            # إضافة وظائف تحليل البيانات إلى وحدة الذكاء الاصطناعي
+            ai_assistant.data_integration = self
+            
+            # إضافة دوال التحليل إلى وحدة الذكاء الاصطناعي
+            ai_assistant.analyze_tender_data = self.analyze_tender_data
+            ai_assistant.analyze_historical_data = self.analyze_historical_data
+            ai_assistant.predict_tender_success = self.predict_tender_success
+            ai_assistant.optimize_pricing = self.optimize_pricing
+            ai_assistant.analyze_dwg_files = self.analyze_dwg_files
+            
+            return True
+        except Exception as e:
+            print(f"خطأ في تكامل وحدة تحليل البيانات مع وحدة الذكاء الاصطناعي: {str(e)}")
+            return False
+    
+    # دوال مساعدة داخلية
+    
+    def _get_historical_data(self):
+        """الحصول على البيانات التاريخية"""
+        # محاكاة البيانات التاريخية
+        np.random.seed(42)
+        
+        n_tenders = 50
+        tender_ids = [f"T-{2021 + i//20}-{i%20 + 1:03d}" for i in range(n_tenders)]
+        tender_types = np.random.choice(["مبنى إداري", "مبنى سكني", "مدرسة", "مستشفى", "طرق", "جسور", "بنية تحتية"], n_tenders)
+        tender_locations = np.random.choice(["الرياض", "جدة", "الدمام", "مكة", "المدينة", "أبها", "تبوك"], n_tenders)
+        tender_areas = np.random.randint(1000, 10000, n_tenders)
+        tender_durations = np.random.randint(6, 36, n_tenders)
+        tender_budgets = np.random.randint(1000000, 50000000, n_tenders)
+        tender_costs = np.array([budget * np.random.uniform(0.8, 1.1) for budget in tender_budgets])
+        tender_profits = tender_budgets - tender_costs
+        tender_profit_margins = tender_profits / tender_budgets * 100
+        tender_statuses = np.random.choice(["فائز", "خاسر", "قيد التنفيذ", "منجز"], n_tenders)
+        tender_dates = [f"202{1 + i//20}-{np.random.randint(1, 13):02d}-{np.random.randint(1, 29):02d}" for i in range(n_tenders)]
+        
+        # إنشاء DataFrame للمناقصات السابقة
+        tenders_data = {
+            "رقم المناقصة": tender_ids,
+            "نوع المشروع": tender_types,
+            "الموقع": tender_locations,
+            "المساحة (م2)": tender_areas,
+            "المدة (شهر)": tender_durations,
+            "الميزانية (ريال)": tender_budgets,
+            "التكلفة (ريال)": tender_costs,
+            "الربح (ريال)": tender_profits,
+            "هامش الربح (%)": tender_profit_margins,
+            "الحالة": tender_statuses,
+            "تاريخ التقديم": tender_dates
+        }
+        
+        return pd.DataFrame(tenders_data)
+    
+    def _get_competitors_data(self):
+        """الحصول على بيانات المنافسين"""
+        # محاكاة بيانات المنافسين
+        n_competitors = 10
+        competitor_ids = [f"C-{i+1:02d}" for i in range(n_competitors)]
+        competitor_names = [
+            "شركة الإنشاءات المتطورة", "شركة البناء الحديث", "شركة التطوير العمراني", "شركة الإعمار الدولية",
+            "شركة البنية التحتية المتكاملة", "شركة المقاولات العامة", "شركة التشييد والبناء", "شركة الهندسة والإنشاءات",
+            "شركة المشاريع الكبرى", "شركة التطوير العقاري"
+        ]
+        competitor_specialties = np.random.choice(["مباني", "طرق", "جسور", "بنية تحتية", "متعددة"], n_competitors)
+        competitor_sizes = np.random.choice(["صغيرة", "متوسطة", "كبيرة"], n_competitors)
+        competitor_market_shares = np.random.uniform(1, 15, n_competitors)
+        competitor_win_rates = np.random.uniform(10, 60, n_competitors)
+        competitor_avg_margins = np.random.uniform(5, 20, n_competitors)
+        
+        # إنشاء DataFrame للمنافسين
+        competitors_data = {
+            "رمز المنافس": competitor_ids,
+            "اسم المنافس": competitor_names,
+            "التخصص": competitor_specialties,
+            "الحجم": competitor_sizes,
+            "حصة السوق (%)": competitor_market_shares,
+            "معدل الفوز (%)": competitor_win_rates,
+            "متوسط هامش الربح (%)": competitor_avg_margins
+        }
+        
+        return pd.DataFrame(competitors_data)
+    
+    def _generate_summary(self, df):
+        """توليد ملخص للبيانات"""
+        # محاكاة توليد ملخص
+        return "تحليل البيانات يشير إلى أن هذه المناقصة تتعلق بمشروع إنشائي متوسط الحجم. تتضمن المناقصة متطلبات فنية متوسطة المستوى وشروط تعاقدية معيارية. بناءً على البيانات التاريخية، هناك فرصة جيدة للفوز بهذه المناقصة إذا تم تقديم عرض تنافسي مع التركيز على الجوانب الفنية والجودة."
+    
+    def _generate_recommendations(self, df):
+        """توليد توصيات بناءً على البيانات"""
+        # محاكاة توليد توصيات
+        return [
+            "تقديم عرض سعر تنافسي يقل بنسبة 5-10% عن الميزانية التقديرية",
+            "التركيز على الخبرات السابقة في مشاريع مماثلة",
+            "تقديم حلول مبتكرة لتقليل مدة التنفيذ",
+            "تعزيز الجوانب الفنية في العرض",
+            "تقديم خطة تنفيذ مفصلة مع جدول زمني واضح"
+        ]
+    
+    def _analyze_risks(self, df):
+        """تحليل المخاطر"""
+        # محاكاة تحليل المخاطر
+        return [
+            {"risk": "ارتفاع أسعار المواد", "probability": "متوسطة", "impact": "عالي", "mitigation": "تثبيت أسعار المواد الرئيسية مع الموردين"},
+            {"risk": "تأخر التنفيذ", "probability": "متوسطة", "impact": "عالي", "mitigation": "وضع خطة تنفيذ مفصلة مع هوامش زمنية"},
+            {"risk": "نقص العمالة الماهرة", "probability": "منخفضة", "impact": "متوسط", "mitigation": "التعاقد المسبق مع مقاولي الباطن"},
+            {"risk": "تغيير نطاق العمل", "probability": "متوسطة", "impact": "عالي", "mitigation": "توثيق نطاق العمل بدقة وتحديد إجراءات التغيير"},
+            {"risk": "مشاكل في التربة", "probability": "منخفضة", "impact": "عالي", "mitigation": "إجراء فحوصات شاملة للتربة قبل البدء"}
+        ]
+    
+    def _analyze_costs(self, df):
+        """تحليل التكاليف"""
+        # محاكاة تحليل التكاليف
+        total_budget = float(df['الميزانية التقديرية'].iloc[0]) if 'الميزانية التقديرية' in df.columns else 10000000
+        
+        # توزيع التكاليف
+        materials_cost = total_budget * 0.6
+        labor_cost = total_budget * 0.25
+        equipment_cost = total_budget * 0.1
+        overhead_cost = total_budget * 0.05
+        
+        return {
+            "total_budget": total_budget,
+            "cost_breakdown": [
+                {"category": "المواد", "amount": materials_cost, "percentage": 60},
+                {"category": "العمالة", "amount": labor_cost, "percentage": 25},
+                {"category": "المعدات", "amount": equipment_cost, "percentage": 10},
+                {"category": "المصاريف العامة", "amount": overhead_cost, "percentage": 5}
+            ],
+            "cost_saving_opportunities": [
+                {"item": "استخدام مواد بديلة", "potential_saving": total_budget * 0.05},
+                {"item": "تحسين إنتاجية العمالة", "potential_saving": total_budget * 0.03},
+                {"item": "تأجير المعدات بدلاً من شرائها", "potential_saving": total_budget * 0.02}
+            ]
+        }
+    
+    def _analyze_competition(self, df):
+        """تحليل المنافسة"""
+        # محاكاة تحليل المنافسة
+        return {
+            "expected_competitors": [
+                {"name": "شركة الإنشاءات المتطورة", "strength": "خبرة طويلة في مشاريع مماثلة", "weakness": "أسعار مرتفعة", "win_probability": 30},
+                {"name": "شركة البناء الحديث", "strength": "أسعار تنافسية", "weakness": "خبرة محدودة", "win_probability": 25},
+                {"name": "شركة التطوير العمراني", "strength": "جودة عالية", "weakness": "بطء في التنفيذ", "win_probability": 20}
+            ],
+            "competitive_advantages": [
+                "خبرة في مشاريع مماثلة",
+                "فريق فني متميز",
+                "علاقات جيدة مع الموردين",
+                "تقنيات حديثة في التنفيذ"
+            ],
+            "competitive_disadvantages": [
+                "محدودية الموارد المالية",
+                "قلة الخبرة في بعض الجوانب الفنية"
+            ]
+        }
+    
+    def _calculate_win_rate(self, df):
+        """حساب معدل الفوز"""
+        # محاكاة حساب معدل الفوز
+        if 'الحالة' in df.columns:
+            total_tenders = len(df)
+            won_tenders = len(df[df['الحالة'] == 'فائز'])
+            win_rate = won_tenders / total_tenders * 100 if total_tenders > 0 else 0
+        else:
+            win_rate = 35  # قيمة افتراضية
+        
+        return {
+            "overall_win_rate": win_rate,
+            "win_rate_by_type": [
+                {"type": "مبنى إداري", "win_rate": 40},
+                {"type": "مبنى سكني", "win_rate": 35},
+                {"type": "مدرسة", "win_rate": 45},
+                {"type": "مستشفى", "win_rate": 30},
+                {"type": "طرق", "win_rate": 25},
+                {"type": "جسور", "win_rate": 20},
+                {"type": "بنية تحتية", "win_rate": 30}
+            ],
+            "win_rate_by_location": [
+                {"location": "الرياض", "win_rate": 40},
+                {"location": "جدة", "win_rate": 35},
+                {"location": "الدمام", "win_rate": 30},
+                {"location": "مكة", "win_rate": 25},
+                {"location": "المدينة", "win_rate": 30},
+                {"location": "أبها", "win_rate": 35},
+                {"location": "تبوك", "win_rate": 40}
+            ]
+        }
+    
+    def _calculate_avg_profit_margin(self, df):
+        """حساب متوسط هامش الربح"""
+        # محاكاة حساب متوسط هامش الربح
+        if 'هامش الربح (%)' in df.columns:
+            avg_profit_margin = df['هامش الربح (%)'].mean()
+        else:
+            avg_profit_margin = 15  # قيمة افتراضية
+        
+        return {
+            "overall_avg_profit_margin": avg_profit_margin,
+            "profit_margin_by_type": [
+                {"type": "مبنى إداري", "profit_margin": 18},
+                {"type": "مبنى سكني", "profit_margin": 15},
+                {"type": "مدرسة", "profit_margin": 20},
+                {"type": "مستشفى", "profit_margin": 12},
+                {"type": "طرق", "profit_margin": 10},
+                {"type": "جسور", "profit_margin": 8},
+                {"type": "بنية تحتية", "profit_margin": 14}
+            ],
+            "profit_margin_by_location": [
+                {"location": "الرياض", "profit_margin": 16},
+                {"location": "جدة", "profit_margin": 14},
+                {"location": "الدمام", "profit_margin": 15},
+                {"location": "مكة", "profit_margin": 12},
+                {"location": "المدينة", "profit_margin": 13},
+                {"location": "أبها", "profit_margin": 18},
+                {"location": "تبوك", "profit_margin": 17}
+            ]
+        }
+    
+    def _analyze_price_trends(self, df):
+        """تحليل اتجاهات الأسعار"""
+        # محاكاة تحليل اتجاهات الأسعار
+        return {
+            "price_trends_by_year": [
+                {"year": 2021, "avg_price_per_sqm": 3500},
+                {"year": 2022, "avg_price_per_sqm": 3800},
+                {"year": 2023, "avg_price_per_sqm": 4200},
+                {"year": 2024, "avg_price_per_sqm": 4500}
+            ],
+            "price_trends_by_material": [
+                {"material": "خرسانة", "price_change": 15},
+                {"material": "حديد", "price_change": 20},
+                {"material": "أسمنت", "price_change": 10},
+                {"material": "طابوق", "price_change": 5},
+                {"material": "ألمنيوم", "price_change": 25}
+            ],
+            "price_forecast": [
+                {"year": 2025, "forecasted_price_change": 8},
+                {"year": 2026, "forecasted_price_change": 5},
+                {"year": 2027, "forecasted_price_change": 3}
+            ]
+        }
+    
+    def _identify_success_factors(self, df):
+        """تحديد عوامل النجاح"""
+        # محاكاة تحديد عوامل النجاح
+        return [
+            {"factor": "السعر التنافسي", "importance": 0.8, "description": "تقديم أسعار أقل من المنافسين بنسبة 5-10%"},
+            {"factor": "الجودة الفنية", "importance": 0.7, "description": "تقديم حلول فنية متميزة ومبتكرة"},
+            {"factor": "الخبرة السابقة", "importance": 0.6, "description": "إظهار خبرة سابقة في مشاريع مماثلة"},
+            {"factor": "مدة التنفيذ", "importance": 0.5, "description": "تقديم جدول زمني أقصر من المطلوب"},
+            {"factor": "السمعة", "importance": 0.4, "description": "سمعة جيدة في السوق وعلاقات قوية مع العملاء"}
+        ]
+    
+    def _generate_visualizations(self, df):
+        """توليد الرسوم البيانية"""
+        # محاكاة توليد الرسوم البيانية
+        return {
+            "visualization_types": [
+                "توزيع المناقصات حسب النوع",
+                "توزيع المناقصات حسب الموقع",
+                "معدل الفوز حسب النوع",
+                "معدل الفوز حسب الموقع",
+                "متوسط هامش الربح حسب النوع",
+                "متوسط هامش الربح حسب الموقع",
+                "اتجاهات الأسعار عبر الزمن"
+            ]
+        }
+    
+    def _generate_success_recommendations(self, factors):
+        """توليد توصيات لزيادة فرص النجاح"""
+        # محاكاة توليد توصيات
+        return [
+            "تخفيض السعر بنسبة 5-10% لزيادة التنافسية",
+            "تعزيز الجوانب الفنية في العرض",
+            "إبراز الخبرات السابقة في مشاريع مماثلة",
+            "تقديم جدول زمني أقصر من المطلوب",
+            "تقديم ضمانات إضافية للجودة"
+        ]
+    
+    def _analyze_market_position(self, price, competitors_df):
+        """تحليل الموقف التنافسي في السوق"""
+        # محاكاة تحليل الموقف التنافسي
+        return {
+            "market_position": "متوسط",
+            "price_percentile": 45,
+            "competitors_below": 3,
+            "competitors_above": 7,
+            "price_competitiveness": "عالية"
+        }
+    
+    def _generate_pricing_recommendations(self, optimal_price, price_sensitivity):
+        """توليد توصيات التسعير"""
+        # محاكاة توليد توصيات التسعير
+        return [
+            f"السعر الأمثل: {optimal_price:,.0f} ريال",
+            "تقديم خصم إضافي للعميل المتكرر",
+            "تقديم خيارات دفع مرنة",
+            "تضمين خدمات إضافية لتعزيز القيمة",
+            "تقديم ضمانات إضافية لتبرير السعر"
+        ]

modules/ai_assistant/document_analyzer.py

@@ -0,0 +1,507 @@
+# -*- coding: utf-8 -*-
+"""
+وحدة تحليل المستندات المتقدمة
+
+هذا الملف يحتوي على الفئات المسؤولة عن تحليل المستندات بشكل احترافي
+باستخدام تقنيات الذكاء الاصطناعي المتقدمة.
+"""
+
+# استيراد المكتبات القياسية
+import os
+import sys
+import logging
+import base64
+import json
+import time
+from io import BytesIO
+from pathlib import Path
+from urllib.parse import urlparse
+from tempfile import NamedTemporaryFile
+
+# استيراد مكتبة Streamlit
+import streamlit as st
+
+# استيراد المكتبات الإضافية
+import requests
+from PIL import Image
+import pandas as pd
+import numpy as np
+
+# تكوين التسجيل
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+try:
+    # استيراد مكتبة pdf2image للتعامل مع ملفات PDF
+    from pdf2image import convert_from_path
+    pdf_conversion_available = True
+except ImportError:
+    pdf_conversion_available = False
+    logger.warning("لم يتم العثور على مكتبة pdf2image. لن يمكن تحويل ملفات PDF إلى صور.")
+
+
+class TextExtractor:
+    """فئة استخراج النصوص من المستندات"""
+    
+    def __init__(self, config=None):
+        """تهيئة مستخرج النصوص"""
+        self.config = config or {}
+        
+    def extract_from_pdf(self, file_path):
+        """استخراج النص من ملف PDF"""
+        try:
+            # محاكاة استخراج النص من PDF
+            # في التطبيق الحقيقي، يمكن استخدام مكتبات مثل PyPDF2 أو pdfplumber
+            return f"تم استخراج النص من ملف PDF: {file_path}"
+        except Exception as e:
+            logger.error(f"خطأ في استخراج النص من PDF: {str(e)}")
+            return f"حدث خطأ أثناء استخراج النص: {str(e)}"
+            
+    def extract_from_docx(self, file_path):
+        """استخراج النص من ملف DOCX"""
+        try:
+            # محاكاة استخراج النص من DOCX
+            # في التطبيق الحقيقي، يمكن استخدام مكتبة python-docx
+            return f"تم استخراج النص من ملف DOCX: {file_path}"
+        except Exception as e:
+            logger.error(f"خطأ في استخراج النص من DOCX: {str(e)}")
+            return f"حدث خطأ أثناء استخراج النص: {str(e)}"
+            
+    def extract_from_image(self, file_path):
+        """استخراج النص من صورة باستخدام OCR"""
+        try:
+            # محاكاة استخراج النص من صورة
+            # في التطبيق الحقيقي، يمكن استخدام مكتبة pytesseract
+            return f"تم استخراج النص من صورة: {file_path}"
+        except Exception as e:
+            logger.error(f"خطأ في استخراج النص من صورة: {str(e)}")
+            return f"حدث خطأ أثناء استخراج النص: {str(e)}"
+            
+    def extract(self, file_path):
+        """استخراج النص من ملف بناءً على نوعه"""
+        _, ext = os.path.splitext(file_path)
+        ext = ext.lower()
+        
+        if ext == '.pdf':
+            return self.extract_from_pdf(file_path)
+        elif ext in ('.doc', '.docx'):
+            return self.extract_from_docx(file_path)
+        elif ext in ('.jpg', '.jpeg', '.png'):
+            return self.extract_from_image(file_path)
+        else:
+            return "نوع ملف غير مدعوم"
+
+
+class ItemExtractor:
+    """فئة استخراج العناصر من المستندات"""
+    
+    def __init__(self, config=None):
+        """تهيئة مستخرج العناصر"""
+        self.config = config or {}
+        
+    def extract_tables(self, document):
+        """استخراج الجداول من المستند"""
+        try:
+            # محاكاة استخراج الجداول
+            # في التطبيق الحقيقي، يمكن استخدام مكتبات مثل camelot-py أو tabula-py
+            return [
+                {
+                    "عنوان": "جدول البنود والكميات",
+                    "بيانات": [
+                        {"البند": "أعمال الحفر", "الكمية": 1000, "الوحدة": "م³", "السعر": 50, "الإجمالي": 50000},
+                        {"البند": "أعمال الخرسانة", "الكمية": 500, "الوحدة": "م³", "السعر": 300, "الإجمالي": 150000},
+                        {"البند": "أعمال التشطيبات", "الكمية": 2000, "الوحدة": "م²", "السعر": 100, "الإجمالي": 200000}
+                    ]
+                },
+                {
+                    "عنوان": "جدول الجدول الزمني",
+                    "بيانات": [
+                        {"المرحلة": "التصميم", "المدة": "30 يوم", "تاريخ البدء": "2025-04-01", "تاريخ الانتهاء": "2025-04-30"},
+                        {"المرحلة": "الإنشاء", "المدة": "180 يوم", "تاريخ البدء": "2025-05-01", "تاريخ الانتهاء": "2025-10-31"},
+                        {"المرحلة": "التسليم", "المدة": "30 يوم", "تاريخ البدء": "2025-11-01", "تاريخ الانتهاء": "2025-11-30"}
+                    ]
+                }
+            ]
+        except Exception as e:
+            logger.error(f"خطأ في استخراج الجداول: {str(e)}")
+            return []
+                
+    def extract_items(self, file_path):
+        """استخراج البنود من المستند"""
+        try:
+            # محاكاة استخراج البنود
+            return [
+                {"بند": "أعمال الحفر والردم", "قيمة": 250000, "نسبة": "10%"},
+                {"بند": "أعمال الخرسانة المسلحة", "قيمة": 750000, "نسبة": "30%"},
+                {"بند": "أعمال التشطيبات", "قيمة": 500000, "نسبة": "20%"},
+                {"بند": "أعمال الكهرباء", "قيمة": 350000, "نسبة": "14%"},
+                {"بند": "أعمال السباكة", "قيمة": 300000, "نسبة": "12%"},
+                {"بند": "أعمال التكييف", "قيمة": 350000, "نسبة": "14%"}
+            ]
+        except Exception as e:
+            logger.error(f"خطأ في استخراج البنود: {str(e)}")
+            return []
+    
+    def extract(self, file_path):
+        """استخراج جميع العناصر من المستند"""
+        return {
+            "بنود": self.extract_items(file_path),
+            "جداول": self.extract_tables(file_path)
+        }
+
+
+class DocumentParser:
+    """فئة تحليل المستندات"""
+    
+    def __init__(self, config=None):
+        """تهيئة محلل المستندات"""
+        self.config = config or {}
+        self.text_extractor = TextExtractor(config)
+        self.item_extractor = ItemExtractor(config)
+        
+    def parse_contract(self, file_path):
+        """تحليل مستند عقد"""
+        try:
+            # محاكاة تحليل عقد
+            return {
+                "نوع المستند": "عقد",
+                "معلومات العقد": {
+                    "رقم العقد": "CT-2025-001",
+                    "تاريخ العقد": "2025-03-15",
+                    "قيمة العقد": "2,500,000 ريال",
+                    "مدة العقد": "12 شهر",
+                    "تاريخ البدء": "2025-04-01",
+                    "تاريخ الانتهاء": "2026-03-31"
+                },
+                "أطراف العقد": {
+                    "الطرف الأول": "وزارة الإسكان",
+                    "الطرف الثاني": "شركة الإنشاءات المتطورة"
+                },
+                "بنود العقد": [
+                    "يلتزم الطرف الثاني بتنفيذ المشروع وفقاً للمواصفات والشروط المرفقة",
+                    "مدة تنفيذ المشروع 12 شهراً من تاريخ استلام الموقع",
+                    "قيمة العقد 2,500,000 ريال شاملة جميع الضرائب والرسوم",
+                    "يتم الدفع على دفعات شهرية حسب نسبة الإنجاز",
+                    "غرامة التأخير 1% من قيمة العقد عن كل أسبوع تأخير بحد أقصى 10%"
+                ],
+                "المرفقات": [
+                    "جدول الكميات",
+                    "المواصفات الفنية",
+                    "الجدول الزمني",
+                    "الضمانات والتأمينات"
+                ],
+                "درجة الثقة": "95%"
+            }
+        except Exception as e:
+            logger.error(f"خطأ في تحليل العقد: {str(e)}")
+            return {"error": f"حدث خطأ أثناء تحليل العقد: {str(e)}"}
+    
+    def parse_tender(self, file_path):
+        """تحليل مستند مناقصة"""
+        try:
+            # محاكاة تحليل مناقصة
+            return {
+                "نوع المستند": "مناقصة",
+                "معلومات المناقصة": {
+                    "رقم المناقصة": "T-2025-002",
+                    "اسم المشروع": "إنشاء مبنى إداري",
+                    "الجهة المالكة": "وزارة المالية",
+                    "تاريخ الطرح": "2025-03-01",
+                    "تاريخ الإقفال": "2025-04-15",
+                    "القيمة التقديرية": "3,000,000 ريال"
+                },
+                "شروط المناقصة": [
+                    "تصنيف المقاول: الدرجة الأولى في مجال المباني",
+                    "خبرة سابقة: 5 مشاريع مماثلة خلال الـ 10 سنوات الماضية",
+                    "الضمان الابتدائي: 2% من قيمة العطاء",
+                    "الضمان النهائي: 5% من قيمة العقد",
+                    "مدة تنفيذ المشروع: 18 شهراً"
+                ],
+                "المستندات المطلوبة": [
+                    "شهادة التصنيف",
+                    "السجل التجاري",
+                    "شهادة الزكاة والدخل",
+                    "شهادة التأمينات الاجتماعية",
+                    "قائمة المشاريع المماثلة"
+                ],
+                "معايير التقييم": [
+                    {"المعيار": "السعر", "الوزن": "50%"},
+                    {"المعيار": "الخبرة الفنية", "الوزن": "25%"},
+                    {"المعيار": "الجدول الزمني", "الوزن": "15%"},
+                    {"المعيار": "فريق العمل", "الوزن": "10%"}
+                ],
+                "درجة الثقة": "92%"
+            }
+        except Exception as e:
+            logger.error(f"خطأ في تحليل المناقصة: {str(e)}")
+            return {"error": f"حدث خطأ أثناء تحليل المناقصة: {str(e)}"}
+    
+    def parse_specifications(self, file_path):
+        """تحليل كراسة الشروط والمواصفات"""
+        try:
+            # محاكاة تحليل كراسة الشروط والمواصفات
+            return {
+                "نوع المستند": "كراسة شروط ومواصفات",
+                "معلومات المشروع": {
+                    "اسم المشروع": "إنشاء مبنى إداري",
+                    "الموقع": "الرياض - حي العليا",
+                    "المساحة": "5000 متر مربع",
+                    "عدد الطوابق": "5 طوابق"
+                },
+                "المواصفات الفنية": {
+                    "الهيكل الإنشائي": "خرسانة مسلحة",
+                    "الواجهات": "زجاج عاكس وحجر طبيعي",
+                    "التشطيبات الداخلية": "رخام للأرضيات، جبس للأسقف، دهانات عالية الجودة للجدران",
+                    "أنظمة الكهرباء": "نظام إنارة LED موفر للطاقة، نظام تحكم ذكي",
+                    "أنظمة التكييف": "نظام تكييف مركزي مع تحكم منفصل لكل منطقة",
+                    "أنظمة السلامة": "نظام إنذار وإطفاء حريق آلي، كاميرات مراقبة، نظام تحكم في الدخول"
+                },
+                "الشروط العامة": [
+                    "الالتزام بكود البناء السعودي",
+                    "الالتزام بمتطلبات الدفاع المدني",
+                    "الالتزام بمتطلبات الاستدامة وكفاءة الطاقة",
+                    "تقديم مخططات تنفيذية معتمدة قبل البدء في التنفيذ",
+                    "تقديم عينات للمواد للاعتماد قبل التوريد"
+                ],
+                "المرفقات": [
+                    "المخططات المعمارية",
+                    "المخططات الإنشائية",
+                    "مخططات الكهرباء",
+                    "مخططات التكييف",
+                    "مخططات السباكة",
+                    "جدول الكميات"
+                ],
+                "درجة الثقة": "90%"
+            }
+        except Exception as e:
+            logger.error(f"خطأ في تحليل كراسة الشروط والمواصفات: {str(e)}")
+            return {"error": f"حدث خطأ أثناء تحليل كراسة الشروط والمواصفات: {str(e)}"}
+    
+    def parse_dwg(self, file_path):
+        """تحليل ملف DWG"""
+        try:
+            # محاكاة تحليل ملف DWG
+            return {
+                "نوع المستند": "ملف DWG",
+                "معلومات الملف": {
+                    "اسم الملف": os.path.basename(file_path),
+                    "حجم الملف": f"{os.path.getsize(file_path) / (1024*1024):.2f} ميجابايت",
+                    "تاريخ التعديل": time.ctime(os.path.getmtime(file_path))
+                },
+                "محتويات الملف": {
+                    "عدد الطبقات": 15,
+                    "عدد الكائنات": 1250,
+                    "أبعاد الرسم": "50م × 30م"
+                },
+                "تحليل المساحات": {
+                    "المساحة الإجمالية": "4,500 م²",
+                    "مساحة البناء": "3,200 م²",
+                    "مساحة الخدمات": "800 م²",
+                    "مساحة الممرات": "500 م²"
+                },
+                "تحليل العناصر": {
+                    "عدد الغرف": 25,
+                    "عدد الأبواب": 40,
+                    "عدد النوافذ": 30,
+                    "عدد الأعمدة": 20
+                },
+                "ملاحظات": [
+                    "تصميم يتوافق مع متطلبات كود البناء السعودي",
+                    "توزيع جيد للمساحات",
+                    "تصميم يراعي متطلبات ذوي الاحتياجات الخاصة",
+                    "تصميم يراعي متطلبات السلامة والإخلاء"
+                ],
+                "درجة الثقة": "85%"
+            }
+        except Exception as e:
+            logger.error(f"خطأ في تحليل ملف DWG: {str(e)}")
+            return {"error": f"حدث خطأ أثناء تحليل ملف DWG: {str(e)}"}
+    
+    def parse(self, file_path):
+        """تحليل المستند بناءً على نوعه"""
+        try:
+            _, ext = os.path.splitext(file_path)
+            ext = ext.lower()
+            
+            # تحديد نوع المستند بناءً على محتواه (محاكاة)
+            file_name = os.path.basename(file_path).lower()
+            
+            if ext == '.dwg':
+                return self.parse_dwg(file_path)
+            elif 'contract' in file_name or 'عقد' in file_name:
+                return self.parse_contract(file_path)
+            elif 'tender' in file_name or 'مناقصة' in file_name:
+                return self.parse_tender(file_path)
+            elif 'spec' in file_name or 'شروط' in file_name or 'مواصفات' in file_name:
+                return self.parse_specifications(file_path)
+            else:
+                # تحليل عام للمستند
+                return {
+                    "نوع المستند": "مستند عام",
+                    "معلومات الملف": {
+                        "اسم الملف": os.path.basename(file_path),
+                        "حجم الملف": f"{os.path.getsize(file_path) / (1024*1024):.2f} ميجابايت",
+                        "تاريخ التعديل": time.ctime(os.path.getmtime(file_path))
+                    },
+                    "محتوى المستند": {
+                        "نص": self.text_extractor.extract(file_path),
+                        "عناصر": self.item_extractor.extract(file_path)
+                    },
+                    "درجة الثقة": "75%"
+                }
+        except Exception as e:
+            logger.error(f"خطأ في تحليل المستند: {str(e)}")
+            return {"error": f"حدث خطأ أثناء تحليل المستند: {str(e)}"}
+
+
+class AIDocumentAnalyzer:
+    """فئة تحليل المستندات باستخدام الذكاء الاصطناعي"""
+    
+    def __init__(self):
+        """تهيئة محلل المستندات الذكي"""
+        self.document_parser = DocumentParser()
+        self.api_keys = {}
+        
+    def set_api_key(self, provider, key):
+        """تعيين مفتاح API لمزود خدمة الذكاء الاصطناعي"""
+        self.api_keys[provider] = key
+        
+    def get_api_key(self, provider):
+        """الحصول على مفتاح API لمزود خدمة الذكاء الاصطناعي"""
+        return self.api_keys.get(provider)
+    
+    def analyze_document(self, file_path, provider="local"):
+        """تحليل المستند باستخدام الذكاء الاصطناعي"""
+        try:
+            # تحليل محلي للمستند
+            local_analysis = self.document_parser.parse(file_path)
+            
+            if provider == "local":
+                return local_analysis
+            
+            # تحليل باستخدام خدمات الذكاء الاصطناعي السحابية
+            if provider == "openai":
+                # محاكاة تحليل باستخدام OpenAI
+                enhanced_analysis = self._enhance_with_openai(local_analysis)
+                return enhanced_analysis
+            elif provider == "claude":
+                # محاكاة تحليل باستخدام Claude
+                enhanced_analysis = self._enhance_with_claude(local_analysis)
+                return enhanced_analysis
+            else:
+                return local_analysis
+        except Exception as e:
+            logger.error(f"خطأ في تحليل المستند: {str(e)}")
+            return {"error": f"حدث خطأ أثناء تحليل المستند: {str(e)}"}
+    
+    def _enhance_with_openai(self, analysis):
+        """تحسين التحليل باستخدام OpenAI"""
+        # محاكاة تحسين التحليل باستخدام OpenAI
+        analysis["مصدر التحليل"] = "OpenAI"
+        analysis["درجة الثقة"] = "98%"
+        
+        # إضافة تحليل المخاطر
+        if "تحليل المخاطر" not in analysis:
+            analysis["تحليل المخاطر"] = [
+                {"المخاطرة": "تأخر التوريدات", "الاحتمالية": "متوسطة", "التأثير": "عالي", "استراتيجية التخفيف": "وضع خطة توريدات بديلة"},
+                {"المخاطرة": "زيادة أسعار المواد", "الاحتمالية": "عالية", "التأثير": "عالي", "استراتيجية التخفيف": "تثبيت أسعار المواد الرئيسية مع الموردين"},
+                {"المخاطرة": "نقص العمالة الماهرة", "الاحتمالية": "متوسطة", "التأثير": "متوسط", "استراتيجية التخفيف": "التعاقد المسبق مع مقاولي الباطن"},
+                {"المخاطرة": "تغيير نطاق العمل", "الاحتمالية": "منخفضة", "التأثير": "عالي", "استراتيجية التخفيف": "توثيق نطاق العمل بدقة وإدارة التغيير"}
+            ]
+        
+        # إضافة توصيات
+        if "التوصيات" not in analysis:
+            analysis["التوصيات"] = [
+                "مراجعة بنود العقد بدقة قبل التوقيع",
+                "التأكد من وضوح نطاق العمل وعدم وجود غموض",
+                "التحقق من توافق المواصفات الفنية مع المعايير المحلية",
+                "وضع خطة إدارة مخاطر شاملة للمشروع",
+                "تخصيص احتياطي للطوارئ بنسبة 10-15% من قيمة المشروع"
+            ]
+        
+        return analysis
+    
+    def _enhance_with_claude(self, analysis):
+        """تحسين التحليل باستخدام Claude"""
+        # محاكاة تحسين التحليل باستخدام Claude
+        analysis["مصدر التحليل"] = "Claude"
+        analysis["درجة الثقة"] = "97%"
+        
+        # إضافة تحليل الفرص
+        if "تحليل الفرص" not in analysis:
+            analysis["تحليل الفرص"] = [
+                {"الفرصة": "تحسين التصميم", "الفائدة": "تقليل التكلفة بنسبة 5-10%", "المتطلبات": "مراجعة هندسية شاملة"},
+                {"الفرصة": "استخدام مواد بديلة", "الفائدة": "تقليل وقت التنفيذ", "المتطلبات": "اعتماد المواصفات الجديدة"},
+                {"الفرصة": "زيادة المحتوى المحلي", "الفائدة": "تحسين التصنيف في برنامج القيمة المضافة", "المتطلبات": "تحديد الموردين المحليين"},
+                {"الفرصة": "تطبيق تقنيات البناء الحديثة", "الفائدة": "تحسين الجودة وتقليل الهدر", "المتطلبات": "تدريب فريق العمل"}
+            ]
+        
+        # إضافة ملخص تنفيذي
+        if "الملخص التنفيذي" not in analysis:
+            analysis["الملخص التنفيذي"] = """
+            يتضمن هذا المستند تفاصيل مشروع إنشاء مبنى إداري بمساحة إجمالية 5000 متر مربع. 
+            المشروع يتكون من 5 طوابق ويتضمن مواصفات فنية عالية الجودة. 
+            تقدر تكلفة المشروع بحوالي 3 مليون ريال ومدة التنفيذ 18 شهراً.
+            يتميز المشروع بتصميم يراعي متطلبات الاستدامة وكفاءة الطاقة.
+            تم تحديد عدة مخاطر محتملة للمشروع مع استراتيجيات التخفيف المناسبة.
+            كما تم تحديد عدة فرص لتحسين المشروع من حيث التكلفة والجودة ووقت التنفيذ.
+            """
+        
+        return analysis
+    
+    def analyze_dwg(self, file_path, provider="local"):
+        """تحليل ملف DWG باستخدام الذكاء الاصطناعي"""
+        try:
+            # تحليل محلي لملف DWG
+            local_analysis = self.document_parser.parse_dwg(file_path)
+            
+            if provider == "local":
+                return local_analysis
+            
+            # تحسين التحليل باستخدام خدمات الذكاء الاصطناعي
+            if provider == "openai" or provider == "claude":
+                # إضافة تحليل متقدم
+                local_analysis["تحليل متقدم"] = {
+                    "تقييم التصميم": "جيد جداً",
+                    "كفاءة استخدام المساحة": "90%",
+                    "توافق مع المعايير": "متوافق مع كود البناء السعودي",
+                    "اقتراحات التحسين": [
+                        "تحسين توزيع المساحات لزيادة كفاءة استخدام المساحة",
+                        "تحسين تصميم الممرات لتسهيل الحركة",
+                        "إضافة عناصر تصميم مستدامة لتقليل استهلاك الطاقة",
+                        "تحسين تصميم الواجهات لزيادة الإضاءة الطبيعية"
+                    ]
+                }
+                
+                # إضافة تقدير التكلفة
+                local_analysis["تقدير التكلفة"] = {
+                    "التكلفة الإجمالية التقديرية": "3,200,000 ريال",
+                    "تكلفة المتر المربع": "800 ريال",
+                    "توزيع التكلفة": [
+                        {"البند": "الهيكل الإنشائي", "النسبة": "35%", "القيمة": "1,120,000 ريال"},
+                        {"البند": "التشطيبات", "النسبة": "25%", "القيمة": "800,000 ريال"},
+                        {"البند": "الأنظمة الكهربائية", "النسبة": "15%", "القيمة": "480,000 ريال"},
+                        {"البند": "الأنظمة الميكانيكية", "النسبة": "15%", "القيمة": "480,000 ريال"},
+                        {"البند": "الأعمال الخارجية", "النسبة": "10%", "القيمة": "320,000 ريال"}
+                    ]
+                }
+                
+                # إضافة الجدول الزمني
+                local_analysis["الجدول الزمني التقديري"] = {
+                    "المدة الإجمالية": "18 شهر",
+                    "المراحل": [
+                        {"المرحلة": "أعمال الحفر والأساسات", "المدة": "3 أشهر", "النسبة": "15%"},
+                        {"المرحلة": "الهيكل الإنشائي", "المدة": "6 أشهر", "النسبة": "35%"},
+                        {"المرحلة": "التشطيبات الداخلية", "المدة": "5 أشهر", "النسبة": "25%"},
+                        {"المرحلة": "الأنظمة الكهربائية والميكانيكية", "المدة": "3 أشهر", "النسبة": "15%"},
+                        {"المرحلة": "الأعمال الخارجية والتسليم", "المدة": "1 شهر", "النسبة": "10%"}
+                    ]
+                }
+                
+                local_analysis["مصدر التحليل"] = provider.capitalize()
+                local_analysis["درجة الثقة"] = "95%"
+            
+            return local_analysis
+        except Exception as e:
+            logger.error(f"خطأ في تحليل ملف DWG: {str(e)}")
+            return {"error": f"حدث خطأ أثناء تحليل ملف DWG: {str(e)}"}

modules/data_analysis/data_analysis_app.py

@@ -0,0 +1,1104 @@
+"""
+وحدة تحليل البيانات - التطبيق الرئيسي
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime
+import time
+import io
+import os
+import json
+import base64
+from pathlib import Path
+
+class DataAnalysisApp:
+    """وحدة تحليل البيانات"""
+    
+    def __init__(self):
+        """تهيئة وحدة تحليل البيانات"""
+        
+        # تهيئة حالة الجلسة
+        if 'uploaded_data' not in st.session_state:
+            st.session_state.uploaded_data = None
+        
+        if 'data_sources' not in st.session_state:
+            st.session_state.data_sources = [
+                {
+                    'id': 1,
+                    'name': 'بيانات المناقصات السابقة',
+                    'type': 'CSV',
+                    'rows': 250,
+                    'columns': 15,
+                    'last_updated': '2024-03-01',
+                    'description': 'بيانات المناقصات السابقة للشركة خلال الثلاث سنوات الماضية'
+                },
+                {
+                    'id': 2,
+                    'name': 'بيانات المنافسين',
+                    'type': 'Excel',
+                    'rows': 120,
+                    'columns': 10,
+                    'last_updated': '2024-02-15',
+                    'description': 'بيانات المنافسين الرئيسيين في السوق وأسعارهم التنافسية'
+                },
+                {
+                    'id': 3,
+                    'name': 'بيانات أسعار المواد',
+                    'type': 'CSV',
+                    'rows': 500,
+                    'columns': 8,
+                    'last_updated': '2024-03-10',
+                    'description': 'بيانات أسعار المواد الرئيسية المستخدمة في المشاريع'
+                },
+                {
+                    'id': 4,
+                    'name': 'بيانات الموردين',
+                    'type': 'Excel',
+                    'rows': 80,
+                    'columns': 12,
+                    'last_updated': '2024-02-20',
+                    'description': 'بيانات الموردين الرئيسيين وأسعارهم وجودة منتجاتهم'
+                },
+                {
+                    'id': 5,
+                    'name': 'بيانات المشاريع المنجزة',
+                    'type': 'CSV',
+                    'rows': 150,
+                    'columns': 20,
+                    'last_updated': '2024-03-15',
+                    'description': 'بيانات المشاريع المنجزة وتكاليفها الفعلية ومدة تنفيذها'
+                }
+            ]
+        
+        if 'sample_data' not in st.session_state:
+            # إنشاء بيانات افتراضية للمناقصات السابقة
+            np.random.seed(42)
+            
+            # إنشاء بيانات المناقصات السابقة
+            n_tenders = 50
+            tender_ids = [f"T-{2021 + i//20}-{i%20 + 1:03d}" for i in range(n_tenders)]
+            tender_types = np.random.choice(["مبنى إداري", "مبنى سكني", "مدرسة", "مستشفى", "طرق", "جسور", "بنية تحتية"], n_tenders)
+            tender_locations = np.random.choice(["الرياض", "جدة", "الدمام", "مكة", "المدينة", "أبها", "تبوك"], n_tenders)
+            tender_areas = np.random.randint(1000, 10000, n_tenders)
+            tender_durations = np.random.randint(6, 36, n_tenders)
+            tender_budgets = np.random.randint(1000000, 50000000, n_tenders)
+            tender_costs = np.array([budget * np.random.uniform(0.8, 1.1) for budget in tender_budgets])
+            tender_profits = tender_budgets - tender_costs
+            tender_profit_margins = tender_profits / tender_budgets * 100
+            tender_statuses = np.random.choice(["فائز", "خاسر", "قيد التنفيذ", "منجز"], n_tenders)
+            tender_dates = [f"202{1 + i//20}-{np.random.randint(1, 13):02d}-{np.random.randint(1, 29):02d}" for i in range(n_tenders)]
+            
+            # إنشاء DataFrame للمناقصات السابقة
+            tenders_data = {
+                "رقم المناقصة": tender_ids,
+                "نوع المشروع": tender_types,
+                "الموقع": tender_locations,
+                "المساحة (م2)": tender_areas,
+                "المدة (شهر)": tender_durations,
+                "الميزانية (ريال)": tender_budgets,
+                "التكلفة (ريال)": tender_costs,
+                "الربح (ريال)": tender_profits,
+                "هامش الربح (%)": tender_profit_margins,
+                "الحالة": tender_statuses,
+                "تاريخ التقديم": tender_dates
+            }
+            
+            st.session_state.sample_data = {
+                "tenders": pd.DataFrame(tenders_data)
+            }
+            
+            # إنشاء بيانات أسعار المواد
+            n_materials = 30
+            material_ids = [f"M-{i+1:03d}" for i in range(n_materials)]
+            material_names = [
+                "خرسانة جاهزة", "حديد تسليح", "طابوق", "أسمنت", "رمل", "بحص", "خشب", "ألمنيوم", "زجاج", "دهان",
+                "سيراميك", "رخام", "جبس", "عازل مائي", "عازل حراري", "أنابيب PVC", "أسلاك كهربائية", "مفاتيح كهربائية",
+                "إنارة", "تكييف", "مصاعد", "أبواب خشبية", "أبواب حديدية", "نوافذ ألمنيوم", "نوافذ زجاجية",
+                "أرضيات خشبية", "أرضيات بلاط", "أرضيات رخام", "أرضيات سيراميك", "أرضيات بورسلين"
+            ]
+            material_units = np.random.choice(["م3", "طن", "م2", "كجم", "لتر", "قطعة", "متر"], n_materials)
+            material_prices_2021 = np.random.randint(50, 5000, n_materials)
+            material_prices_2022 = np.array([price * np.random.uniform(1.0, 1.2) for price in material_prices_2021])
+            material_prices_2023 = np.array([price * np.random.uniform(1.0, 1.15) for price in material_prices_2022])
+            material_prices_2024 = np.array([price * np.random.uniform(0.95, 1.1) for price in material_prices_2023])
+            
+            # إنشاء DataFrame لأسعار المواد
+            materials_data = {
+                "رمز المادة": material_ids,
+                "اسم المادة": material_names,
+                "الوحدة": material_units,
+                "سعر 2021 (ريال)": material_prices_2021,
+                "سعر 2022 (ريال)": material_prices_2022,
+                "سعر 2023 (ريال)": material_prices_2023,
+                "سعر 2024 (ريال)": material_prices_2024,
+                "نسبة التغير 2021-2024 (%)": (material_prices_2024 - material_prices_2021) / material_prices_2021 * 100
+            }
+            
+            st.session_state.sample_data["materials"] = pd.DataFrame(materials_data)
+            
+            # إنشاء بيانات المنافسين
+            n_competitors = 10
+            competitor_ids = [f"C-{i+1:02d}" for i in range(n_competitors)]
+            competitor_names = [
+                "شركة الإنشاءات المتطورة", "شركة البناء الحديث", "شركة التطوير العمراني", "شركة الإعمار الدولية",
+                "شركة البنية التحتية المتكاملة", "شركة المقاولات العامة", "شركة التشييد والبناء", "شركة الهندسة والإنشاءات",
+                "شركة المشاريع الكبرى", "شركة التطوير العقاري"
+            ]
+            competitor_specialties = np.random.choice(["مباني", "طرق", "جسور", "بنية تحتية", "متعددة"], n_competitors)
+            competitor_sizes = np.random.choice(["صغيرة", "متوسطة", "كبيرة"], n_competitors)
+            competitor_market_shares = np.random.uniform(1, 15, n_competitors)
+            competitor_win_rates = np.random.uniform(10, 60, n_competitors)
+            competitor_avg_margins = np.random.uniform(5, 20, n_competitors)
+            
+            # إنشاء DataFrame للمنافسين
+            competitors_data = {
+                "رمز المنافس": competitor_ids,
+                "اسم المنافس": competitor_names,
+                "التخصص": competitor_specialties,
+                "الحجم": competitor_sizes,
+                "حصة السوق (%)": competitor_market_shares,
+                "معدل الفوز (%)": competitor_win_rates,
+                "متوسط هامش الربح (%)": competitor_avg_margins
+            }
+            
+            st.session_state.sample_data["competitors"] = pd.DataFrame(competitors_data)
+    
+    def run(self):
+        """
+        تشغيل وحدة تحليل البيانات
+        
+        هذه الدالة هي نقطة الدخول الرئيسية لوحدة تحليل البيانات.
+        تقوم بتهيئة واجهة المستخدم وعرض البيانات والتحليلات.
+        """
+        try:
+            # تعيين عنوان الصفحة
+            st.set_page_config(
+                page_title="وحدة تحليل البيانات - نظام المناقصات",
+                page_icon="📊",
+                layout="wide",
+                initial_sidebar_state="expanded"
+            )
+            
+            # تطبيق التنسيق المخصص
+            st.markdown("""
+            <style>
+            .module-title {
+                color: #2c3e50;
+                text-align: center;
+                font-size: 2.5rem;
+                margin-bottom: 1rem;
+                padding-bottom: 1rem;
+                border-bottom: 2px solid #3498db;
+            }
+            .stTabs [data-baseweb="tab-list"] {
+                gap: 10px;
+            }
+            .stTabs [data-baseweb="tab"] {
+                height: 50px;
+                white-space: pre-wrap;
+                background-color: #f8f9fa;
+                border-radius: 4px 4px 0px 0px;
+                gap: 1px;
+                padding-top: 10px;
+                padding-bottom: 10px;
+            }
+            .stTabs [aria-selected="true"] {
+                background-color: #3498db;
+                color: white;
+            }
+            </style>
+            """, unsafe_allow_html=True)
+            
+            # عرض الشريط الجانبي
+            with st.sidebar:
+                st.image("/home/ubuntu/tender_system/tender_system/assets/images/logo.png", width=200)
+                st.markdown("## نظام تحليل المناقصات")
+                st.markdown("### وحدة تحليل البيانات")
+                
+                st.markdown("---")
+                
+                # إضافة خيارات التصفية العامة
+                st.markdown("### خيارات التصفية العامة")
+                
+                # إضافة مزيد من الخيارات حسب الحاجة
+                st.markdown("---")
+                
+                # إضافة معلومات المستخدم
+                st.markdown("### معلومات المستخدم")
+                st.markdown("**المستخدم:** مهندس تامر الجوهري")
+                st.markdown("**الدور:** محلل بيانات")
+                st.markdown("**تاريخ آخر دخول:** " + datetime.now().strftime("%Y-%m-%d %H:%M"))
+            
+            # عرض واجهة وحدة تحليل البيانات
+            self.render()
+            
+            # إضافة معلومات في أسفل الصفحة
+            st.markdown("---")
+            st.markdown("### نظام تحليل المناقصات - وحدة تحليل البيانات")
+            st.markdown("**الإصدار:** 2.0.0")
+            st.markdown("**تاريخ التحديث:** 2024-03-31")
+            st.markdown("**جميع الحقوق محفوظة © 2024**")
+            
+            return True
+            
+        except Exception as e:
+            st.error(f"حدث خطأ أثناء تشغيل وحدة تحليل البيانات: {str(e)}")
+            return False
+    
+    def render(self):
+        """عرض واجهة وحدة تحليل البيانات"""
+        
+        st.markdown("<h1 class='module-title'>وحدة تحليل البيانات</h1>", unsafe_allow_html=True)
+        
+        tabs = st.tabs([
+            "لوحة المعلومات", 
+            "تحليل المناقصات",
+            "تحليل الأسعار",
+            "تحليل المنافسين",
+            "استيراد وتصدير البيانات"
+        ])
+        
+        with tabs[0]:
+            self._render_dashboard_tab()
+        
+        with tabs[1]:
+            self._render_tenders_analysis_tab()
+        
+        with tabs[2]:
+            self._render_price_analysis_tab()
+        
+        with tabs[3]:
+            self._render_competitors_analysis_tab()
+        
+        with tabs[4]:
+            self._render_import_export_tab()
+    
+    def _render_dashboard_tab(self):
+        """عرض تبويب لوحة المعلومات"""
+        
+        st.markdown("### لوحة المعلومات")
+        
+        # عرض مؤشرات الأداء الرئيسية
+        st.markdown("#### مؤشرات الأداء الرئيسية")
+        
+        # استخراج البيانات اللازمة للمؤشرات
+        tenders_df = st.session_state.sample_data["tenders"]
+        
+        # حساب المؤشرات
+        total_tenders = len(tenders_df)
+        won_tenders = len(tenders_df[tenders_df["الحالة"] == "فائز"])
+        win_rate = won_tenders / total_tenders * 100
+        avg_profit_margin = tenders_df["هامش الربح (%)"].mean()
+        total_profit = tenders_df["الربح (ريال)"].sum()
+        
+        # عرض المؤشرات
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            st.metric("إجمالي المناقصات", f"{total_tenders}")
+        
+        with col2:
+            st.metric("معدل الفوز", f"{win_rate:.1f}%")
+        
+        with col3:
+            st.metric("متوسط هامش الربح", f"{avg_profit_margin:.1f}%")
+        
+        with col4:
+            st.metric("إجمالي الربح", f"{total_profit:,.0f} ريال")
+        
+        # عرض توزيع المناقصات حسب الحالة
+        st.markdown("#### توزيع المناقصات حسب الحالة")
+        
+        status_counts = tenders_df["الحالة"].value_counts().reset_index()
+        status_counts.columns = ["الحالة", "العدد"]
+        
+        fig = px.pie(
+            status_counts,
+            values="العدد",
+            names="الحالة",
+            title="توزيع المناقصات حسب الحالة",
+            color="الحالة",
+            color_discrete_map={
+                "فائز": "#2ecc71",
+                "خاسر": "#e74c3c",
+                "قيد التنفيذ": "#3498db",
+                "منجز": "#f39c12"
+            }
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع المناقصات حسب نوع المشروع
+        st.markdown("#### توزيع المناقصات حسب نوع المشروع")
+        
+        type_counts = tenders_df["نوع المشروع"].value_counts().reset_index()
+        type_counts.columns = ["نوع المشروع", "العدد"]
+        
+        fig = px.bar(
+            type_counts,
+            x="نوع المشروع",
+            y="العدد",
+            title="توزيع المناقصات حسب نوع المشروع",
+            color="نوع المشروع",
+            text_auto=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض تطور هامش الربح عبر الزمن
+        st.markdown("#### تطور هامش الربح عبر الزمن")
+        
+        # إضافة عمود السنة
+        tenders_df["السنة"] = tenders_df["تاريخ التقديم"].str[:4]
+        
+        # حساب متوسط هامش الربح لكل سنة
+        profit_margin_by_year = tenders_df.groupby("السنة")["هامش الربح (%)"].mean().reset_index()
+        
+        fig = px.line(
+            profit_margin_by_year,
+            x="السنة",
+            y="هامش الربح (%)",
+            title="تطور متوسط هامش الربح عبر السنوات",
+            markers=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع المناقصات حسب الموقع
+        st.markdown("#### توزيع المناقصات حسب الموقع")
+        
+        location_counts = tenders_df["الموقع"].value_counts().reset_index()
+        location_counts.columns = ["الموقع", "العدد"]
+        
+        fig = px.bar(
+            location_counts,
+            x="الموقع",
+            y="العدد",
+            title="توزيع المناقصات حسب الموقع",
+            color="الموقع",
+            text_auto=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض العلاقة بين الميزانية والتكلفة
+        st.markdown("#### العلاقة بين الميزانية والتكلفة")
+        
+        fig = px.scatter(
+            tenders_df,
+            x="الميزانية (ريال)",
+            y="التكلفة (ريال)",
+            color="الحالة",
+            size="المساحة (م2)",
+            hover_name="رقم المناقصة",
+            hover_data=["نوع المشروع", "الموقع", "هامش الربح (%)"],
+            title="العلاقة بين الميزانية والتكلفة",
+            color_discrete_map={
+                "فائز": "#2ecc71",
+                "خاسر": "#e74c3c",
+                "قيد التنفيذ": "#3498db",
+                "منجز": "#f39c12"
+            }
+        )
+        
+        # إضافة خط الميزانية = التكلفة
+        max_value = max(tenders_df["الميزانية (ريال)"].max(), tenders_df["التكلفة (ريال)"].max())
+        fig.add_trace(
+            go.Scatter(
+                x=[0, max_value],
+                y=[0, max_value],
+                mode="lines",
+                line=dict(color="gray", dash="dash"),
+                name="الميزانية = التكلفة"
+            )
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_tenders_analysis_tab(self):
+        """عرض تبويب تحليل المناقصات"""
+        
+        st.markdown("### تحليل المناقصات")
+        
+        # استخراج البيانات
+        tenders_df = st.session_state.sample_data["tenders"]
+        
+        # عرض خيارات التصفية
+        st.markdown("#### خيارات التصفية")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            selected_status = st.multiselect(
+                "الحالة",
+                options=tenders_df["الحالة"].unique(),
+                default=tenders_df["الحالة"].unique()
+            )
+        
+        with col2:
+            selected_types = st.multiselect(
+                "نوع المشروع",
+                options=tenders_df["نوع المشروع"].unique(),
+                default=tenders_df["نوع المشروع"].unique()
+            )
+        
+        with col3:
+            selected_locations = st.multiselect(
+                "الموقع",
+                options=tenders_df["الموقع"].unique(),
+                default=tenders_df["الموقع"].unique()
+            )
+        
+        # تطبيق التصفية
+        filtered_df = tenders_df[
+            tenders_df["الحالة"].isin(selected_status) &
+            tenders_df["نوع المشروع"].isin(selected_types) &
+            tenders_df["الموقع"].isin(selected_locations)
+        ]
+        
+        # عرض البيانات المصفاة
+        st.markdown("#### البيانات المصفاة")
+        
+        st.dataframe(filtered_df, use_container_width=True, hide_index=True)
+        
+        # عرض إحصائيات البيانات المصفاة
+        st.markdown("#### إحصائيات البيانات المصفاة")
+        
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            st.metric("عدد المناقصات", f"{len(filtered_df)}")
+        
+        with col2:
+            won_count = len(filtered_df[filtered_df["الحالة"] == "فائز"])
+            win_rate = won_count / len(filtered_df) * 100 if len(filtered_df) > 0 else 0
+            st.metric("معدل الفوز", f"{win_rate:.1f}%")
+        
+        with col3:
+            avg_profit_margin = filtered_df["هامش الربح (%)"].mean()
+            st.metric("متوسط هامش الربح", f"{avg_profit_margin:.1f}%")
+        
+        with col4:
+            total_profit = filtered_df["الربح (ريال)"].sum()
+            st.metric("إجمالي الربح", f"{total_profit:,.0f} ريال")
+        
+        # عرض تحليل هامش الربح حسب نوع المشروع
+        st.markdown("#### تحليل هامش الربح حسب نوع المشروع")
+        
+        profit_margin_by_type = filtered_df.groupby("نوع المشروع")["هامش الربح (%)"].mean().reset_index()
+        
+        fig = px.bar(
+            profit_margin_by_type,
+            x="نوع المشروع",
+            y="هامش الربح (%)",
+            title="متوسط هامش الربح حسب نوع المشروع",
+            color="نوع المشروع",
+            text_auto=".1f"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض تحليل هامش الربح حسب الموقع
+        st.markdown("#### تحليل هامش الربح حسب الموقع")
+        
+        profit_margin_by_location = filtered_df.groupby("الموقع")["هامش الربح (%)"].mean().reset_index()
+        
+        fig = px.bar(
+            profit_margin_by_location,
+            x="الموقع",
+            y="هامش الربح (%)",
+            title="متوسط هامش الربح حسب الموقع",
+            color="الموقع",
+            text_auto=".1f"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض تحليل معدل الفوز حسب نوع المشروع
+        st.markdown("#### تحليل معدل الفوز حسب نوع المشروع")
+        
+        # حساب معدل الفوز لكل نوع مشروع
+        win_rate_by_type = []
+        
+        for project_type in filtered_df["نوع المشروع"].unique():
+            type_df = filtered_df[filtered_df["نوع المشروع"] == project_type]
+            won_count = len(type_df[type_df["الحالة"] == "فائز"])
+            total_count = len(type_df)
+            win_rate = won_count / total_count * 100 if total_count > 0 else 0
+            win_rate_by_type.append({
+                "نوع المشروع": project_type,
+                "معدل الفوز (%)": win_rate,
+                "عدد المناقصات": total_count
+            })
+        
+        win_rate_by_type_df = pd.DataFrame(win_rate_by_type)
+        
+        fig = px.bar(
+            win_rate_by_type_df,
+            x="نوع المشروع",
+            y="معدل الفوز (%)",
+            title="معدل الفوز حسب نوع المشروع",
+            color="نوع المشروع",
+            text_auto=".1f",
+            hover_data=["عدد المناقصات"]
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض تحليل العلاقة بين حجم المشروع وهامش الربح
+        st.markdown("#### العلاقة بين حجم المشروع وهامش الربح")
+        
+        fig = px.scatter(
+            filtered_df,
+            x="الميزانية (ريال)",
+            y="هامش الربح (%)",
+            color="الحالة",
+            size="المساحة (م2)",
+            hover_name="رقم المناقصة",
+            hover_data=["نوع المشروع", "الموقع", "المدة (شهر)"],
+            title="العلاقة بين حجم المشروع وهامش الربح",
+            color_discrete_map={
+                "فائز": "#2ecc71",
+                "خاسر": "#e74c3c",
+                "قيد التنفيذ": "#3498db",
+                "منجز": "#f39c12"
+            }
+        )
+        
+        # إضافة خط الاتجاه
+        fig.update_layout(
+            shapes=[
+                dict(
+                    type="line",
+                    xref="x",
+                    yref="y",
+                    x0=filtered_df["الميزانية (ريال)"].min(),
+                    y0=filtered_df["هامش الربح (%)"].mean(),
+                    x1=filtered_df["الميزانية (ريال)"].max(),
+                    y1=filtered_df["هامش الربح (%)"].mean(),
+                    line=dict(color="gray", dash="dash")
+                )
+            ]
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض تحليل العلاقة بين مدة المشروع وهامش الربح
+        st.markdown("#### العلاقة بين مدة المشروع وهامش الربح")
+        
+        fig = px.scatter(
+            filtered_df,
+            x="المدة (شهر)",
+            y="هامش الربح (%)",
+            color="الحالة",
+            size="الميزانية (ريال)",
+            hover_name="رقم المناقصة",
+            hover_data=["نوع المشروع", "الموقع", "المساحة (م2)"],
+            title="العلاقة بين مدة المشروع وهامش الربح",
+            color_discrete_map={
+                "فائز": "#2ecc71",
+                "خاسر": "#e74c3c",
+                "قيد التنفيذ": "#3498db",
+                "منجز": "#f39c12"
+            }
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_price_analysis_tab(self):
+        """عرض تبويب تحليل الأسعار"""
+        
+        st.markdown("### تحليل الأسعار")
+        
+        # استخراج البيانات
+        materials_df = st.session_state.sample_data["materials"]
+        
+        # عرض بيانات أسعار المواد
+        st.markdown("#### بيانات أسعار المواد")
+        
+        st.dataframe(materials_df, use_container_width=True, hide_index=True)
+        
+        # عرض تطور أسعار المواد عبر السنوات
+        st.markdown("#### تطور أسعار المواد عبر السنوات")
+        
+        # اختيار المواد للعرض
+        selected_materials = st.multiselect(
+            "اختر المواد للعرض",
+            options=materials_df["اسم المادة"].unique(),
+            default=materials_df["اسم المادة"].unique()[:5]
+        )
+        
+        if selected_materials:
+            # تحضير البيانات للرسم البياني
+            filtered_materials = materials_df[materials_df["اسم المادة"].isin(selected_materials)]
+            
+            # تحويل البيانات من العرض العريض إلى العرض الطويل
+            melted_df = pd.melt(
+                filtered_materials,
+                id_vars=["رمز المادة", "اسم المادة", "الوحدة"],
+                value_vars=["سعر 2021 (ريال)", "سعر 2022 (ريال)", "سعر 2023 (ريال)", "سعر 2024 (ريال)"],
+                var_name="السنة",
+                value_name="السعر (ريال)"
+            )
+            
+            # استخراج السنة من اسم العمود
+            melted_df["السنة"] = melted_df["السنة"].str.extract(r"سعر (\d{4})")
+            
+            # رسم بياني لتطور الأسعار
+            fig = px.line(
+                melted_df,
+                x="السنة",
+                y="السعر (ريال)",
+                color="اسم المادة",
+                title="تطور أسعار المواد عبر السنوات",
+                markers=True,
+                hover_data=["الوحدة"]
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض نسبة التغير في أسعار المواد
+        st.markdown("#### نسبة التغير في أسعار المواد (2021-2024)")
+        
+        # ترتيب المواد حسب نسبة التغير
+        sorted_materials = materials_df.sort_values("نسبة التغير 2021-2024 (%)", ascending=False)
+        
+        fig = px.bar(
+            sorted_materials,
+            x="اسم المادة",
+            y="نسبة التغير 2021-2024 (%)",
+            title="نسبة التغير في أسعار المواد (2021-2024)",
+            color="نسبة التغير 2021-2024 (%)",
+            color_continuous_scale="RdYlGn_r",
+            text_auto=".1f"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع أسعار المواد حسب الفئة
+        st.markdown("#### توزيع أسعار المواد حسب الفئة")
+        
+        # تصنيف المواد إلى فئات
+        materials_df["فئة المادة"] = materials_df["اسم المادة"].apply(
+            lambda x: "مواد إنشائية" if x in ["خرسانة جاهزة", "حديد تسليح", "طابوق", "أسمنت", "رمل", "بحص", "خشب"]
+            else "مواد تشطيب" if x in ["ألمنيوم", "زجاج", "دهان", "سيراميك", "رخام", "جبس", "عازل مائي", "عازل حراري"]
+            else "مواد كهربائية" if x in ["أنابيب PVC", "أسلاك كهربائية", "مفاتيح كهربائية", "إنارة"]
+            else "مواد ميكانيكية" if x in ["تكييف", "مصاعد"]
+            else "أبواب ونوافذ" if x in ["أبواب خشبية", "أبواب حديدية", "نوافذ ألمنيوم", "نوافذ زجاجية"]
+            else "أرضيات" if x in ["أرضيات خشبية", "أرضيات بلاط", "أرضيات رخام", "أرضيات سيراميك", "أرضيات بورسلين"]
+            else "أخرى"
+        )
+        
+        # حساب متوسط نسبة التغير لكل فئة
+        category_change = materials_df.groupby("فئة المادة")["نسبة التغير 2021-2024 (%)"].mean().reset_index()
+        
+        fig = px.bar(
+            category_change,
+            x="فئة المادة",
+            y="نسبة التغير 2021-2024 (%)",
+            title="متوسط نسبة التغير في أسعار المواد حسب الفئة (2021-2024)",
+            color="فئة المادة",
+            text_auto=".1f"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض تحليل تأثير تغير الأسعار على تكاليف المشاريع
+        st.markdown("#### تحليل تأثير تغير الأسعار على تكاليف المشاريع")
+        
+        # إنشاء بيانات افتراضية لتوزيع التكاليف
+        cost_distribution = {
+            "الفئة": [
+                "مواد إنشائية",
+                "مواد تشطيب",
+                "مواد كهربائية",
+                "مواد ميكانيكية",
+                "أبواب ونوافذ",
+                "أرضيات",
+                "عمالة",
+                "معدات",
+                "نفقات عامة"
+            ],
+            "النسبة من التكلفة (%)": [30, 20, 10, 15, 5, 5, 10, 3, 2]
+        }
+        
+        cost_distribution_df = pd.DataFrame(cost_distribution)
+        
+        # حساب تأثير تغير الأسعار على التكاليف
+        impact_data = []
+        
+        for index, row in cost_distribution_df.iterrows():
+            category = row["الفئة"]
+            cost_percentage = row["النسبة من التكلفة (%)"]
+            
+            if category in category_change["فئة المادة"].values:
+                price_change = category_change[category_change["فئة المادة"] == category]["نسبة التغير 2021-2024 (%)"].values[0]
+            else:
+                # افتراض نسبة تغير للفئات غير المدرجة
+                price_change = 10 if category == "عمالة" else 5
+            
+            impact = cost_percentage * price_change / 100
+            
+            impact_data.append({
+                "الفئة": category,
+                "النسبة من التكلفة (%)": cost_percentage,
+                "نسبة التغير في الأسعار (%)": price_change,
+                "التأثير على التكلفة الإجمالية (%)": impact
+            })
+        
+        impact_df = pd.DataFrame(impact_data)
+        
+        # حساب إجمالي التأثير على التكلفة
+        total_impact = impact_df["التأثير على التكلفة الإجمالية (%)"].sum()
+        
+        st.metric("إجمالي التأثير على التكلفة", f"{total_impact:.1f}%")
+        
+        # عرض جدول التأثير
+        st.dataframe(impact_df, use_container_width=True, hide_index=True)
+        
+        # رسم بياني للتأثير على التكلفة
+        fig = px.bar(
+            impact_df,
+            x="الفئة",
+            y="التأثير على التكلفة الإجمالية (%)",
+            title="تأثير تغير الأسعار على التكلفة الإجمالية للمشاريع",
+            color="الفئة",
+            text_auto=".1f"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توصيات لإدارة تغير الأسعار
+        st.markdown("#### توصيات لإدارة تغير الأسعار")
+        
+        st.markdown("""
+        1. **التعاقد المسبق مع الموردين:** التعاقد المسبق مع الموردين لتثبيت الأسعار لفترة زمنية محددة.
+        2. **تنويع مصادر التوريد:** تنويع مصادر التوريد لتقليل مخاطر ارتفاع الأسعار من مصدر واحد.
+        3. **شراء المواد مقدماً:** شراء المواد الرئيسية مقدماً للمشاريع المستقبلية عندما تكون الأسعار منخفضة.
+        4. **استخدام مواد بديلة:** استخدام مواد بديلة ذات جودة مماثلة وأسعار أقل.
+        5. **تضمين بند تعديل الأسعار في العقود:** تضمين بند تعديل الأسعار في العقود لتغطية التغيرات الكبيرة في أسعار المواد.
+        6. **تحسين كفاءة استخدام المواد:** تحسين كفاءة استخدام المواد لتقليل الهدر وتقليل التكاليف.
+        7. **مراقبة اتجاهات الأسعار:** مراقبة اتجاهات الأسعار بشكل مستمر واتخاذ القرارات بناءً على التوقعات المستقبلية.
+        """)
+    
+    def _render_competitors_analysis_tab(self):
+        """عرض تبويب تحليل المنافسين"""
+        
+        st.markdown("### تحليل المنافسين")
+        
+        # استخراج البيانات
+        competitors_df = st.session_state.sample_data["competitors"]
+        
+        # عرض بيانات المنافسين
+        st.markdown("#### بيانات المنافسين")
+        
+        st.dataframe(competitors_df, use_container_width=True, hide_index=True)
+        
+        # عرض حصص السوق للمنافسين
+        st.markdown("#### حصص السوق للمنافسين")
+        
+        # ترتيب المنافسين حسب حصة السوق
+        sorted_competitors = competitors_df.sort_values("حصة السوق (%)", ascending=False)
+        
+        fig = px.pie(
+            sorted_competitors,
+            values="حصة السوق (%)",
+            names="اسم المنافس",
+            title="حصص السوق للمنافسين",
+            hover_data=["التخصص", "الحجم"]
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض معدلات الفوز للمنافسين
+        st.markdown("#### معدلات الفوز للمنافسين")
+        
+        # ترتيب المنافسين حسب معدل الفوز
+        sorted_by_win_rate = competitors_df.sort_values("معدل الفوز (%)", ascending=False)
+        
+        fig = px.bar(
+            sorted_by_win_rate,
+            x="اسم المنافس",
+            y="معدل الفوز (%)",
+            title="معدلات الفوز للمنافسين",
+            color="معدل الفوز (%)",
+            text_auto=".1f",
+            hover_data=["التخصص", "الحجم", "حصة السوق (%)"]
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض متوسط هوامش الربح للمنافسين
+        st.markdown("#### متوسط هوامش الربح للمنافسين")
+        
+        # ترتيب المنافسين حسب متوسط هامش الربح
+        sorted_by_margin = competitors_df.sort_values("متوسط هامش الربح (%)", ascending=False)
+        
+        fig = px.bar(
+            sorted_by_margin,
+            x="اسم المنافس",
+            y="متوسط هامش الربح (%)",
+            title="متوسط هوامش الربح للمنافسين",
+            color="متوسط هامش الربح (%)",
+            text_auto=".1f",
+            hover_data=["التخصص", "الحجم", "حصة السوق (%)"]
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض تحليل المنافسين حسب التخصص
+        st.markdown("#### تحليل المنافسين حسب التخصص")
+        
+        # حساب متوسط معدل الفوز وهامش الربح لكل تخصص
+        specialty_analysis = competitors_df.groupby("التخصص").agg({
+            "معدل الفوز (%)": "mean",
+            "متوسط هامش الربح (%)": "mean",
+            "حصة السوق (%)": "sum"
+        }).reset_index()
+        
+        # عرض تحليل التخصصات
+        st.dataframe(specialty_analysis, use_container_width=True, hide_index=True)
+        
+        # رسم بياني للعلاقة بين معدل الفوز وهامش الربح حسب التخصص
+        fig = px.scatter(
+            specialty_analysis,
+            x="معدل الفوز (%)",
+            y="متوسط هامش الربح (%)",
+            size="حصة السو�� (%)",
+            color="التخصص",
+            hover_name="التخصص",
+            title="العلاقة بين معدل الفوز وهامش الربح حسب التخصص",
+            text="التخصص"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض تحليل المنافسين حسب الحجم
+        st.markdown("#### تحليل المنافسين حسب الحجم")
+        
+        # حساب متوسط معدل الفوز وهامش الربح لكل حجم
+        size_analysis = competitors_df.groupby("الحجم").agg({
+            "معدل الفوز (%)": "mean",
+            "متوسط هامش الربح (%)": "mean",
+            "حصة السوق (%)": "sum"
+        }).reset_index()
+        
+        # عرض تحليل الأحجام
+        st.dataframe(size_analysis, use_container_width=True, hide_index=True)
+        
+        # رسم بياني للعلاقة بين معدل الفوز وهامش الربح حسب الحجم
+        fig = px.scatter(
+            size_analysis,
+            x="معدل الفوز (%)",
+            y="متوسط هامش الربح (%)",
+            size="حصة السوق (%)",
+            color="الحجم",
+            hover_name="الحجم",
+            title="العلاقة بين معدل الفوز وهامش الربح حسب الحجم",
+            text="الحجم"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض تحليل نقاط القوة والضعف للمنافسين
+        st.markdown("#### تحليل نقاط القوة والضعف للمنافسين الرئيسيين")
+        
+        # اختيار المنافسين للتحليل
+        top_competitors = competitors_df.sort_values("حصة السوق (%)", ascending=False).head(3)
+        
+        for index, competitor in top_competitors.iterrows():
+            with st.expander(f"{competitor['اسم المنافس']} - حصة السوق: {competitor['حصة السوق (%)']:.1f}%"):
+                st.markdown(f"**التخصص:** {competitor['التخصص']}")
+                st.markdown(f"**الحجم:** {competitor['الحجم']}")
+                st.markdown(f"**معدل الفوز:** {competitor['معدل الفوز (%)']:.1f}%")
+                st.markdown(f"**متوسط هامش الربح:** {competitor['متوسط هامش الربح (%)']:.1f}%")
+                
+                st.markdown("**نقاط القوة:**")
+                if competitor["الحجم"] == "كبيرة":
+                    st.markdown("- قدرة مالية كبيرة")
+                    st.markdown("- خبرة واسعة في المشاريع الكبيرة")
+                    st.markdown("- سمعة قوية في السوق")
+                    st.markdown("- شبكة علاقات واسعة")
+                elif competitor["الحجم"] == "متوسطة":
+                    st.markdown("- مرونة في التعامل مع المشاريع")
+                    st.markdown("- تكاليف تشغيلية أقل")
+                    st.markdown("- تخصص في مجالات محددة")
+                    st.markdown("- سرعة في اتخاذ القرارات")
+                else:
+                    st.markdown("- مرونة عالية")
+                    st.markdown("- تكاليف تشغيلية منخفضة")
+                    st.markdown("- خدمة عملاء متميزة")
+                    st.markdown("- تخصص دقيق في مجال محدد")
+                
+                st.markdown("**نقاط الضعف:**")
+                if competitor["الحجم"] == "كبيرة":
+                    st.markdown("- بطء في اتخاذ القرارات")
+                    st.markdown("- تكاليف تشغيلية عالية")
+                    st.markdown("- أقل مرونة في التعامل مع التغييرات")
+                    st.markdown("- تركيز على المشاريع الكبيرة فقط")
+                elif competitor["الحجم"] == "متوسطة":
+                    st.markdown("- قدرة مالية محدودة مقارنة بالشركات الكبيرة")
+                    st.markdown("- صعوبة في المنافسة على المشاريع الكبيرة")
+                    st.markdown("- محدودية الموارد البشرية")
+                    st.markdown("- صعوبة في الحصول على تمويل")
+                else:
+                    st.markdown("- قدرة مالية محدودة جداً")
+                    st.markdown("- صعوبة في المنافسة على المشاريع المتوسطة والكبيرة")
+                    st.markdown("- محدودية الموارد البشرية والفنية")
+                    st.markdown("- صعوبة في الحصول على تمويل")
+        
+        # عرض توصيات للتعامل مع المنافسين
+        st.markdown("#### توصيات للتعامل مع المنافسين")
+        
+        st.markdown("""
+        1. **التركيز على نقاط القوة:** التركيز على نقاط القوة الخاصة بالشركة والتي تميزها عن المنافسين.
+        2. **استهداف شرائح سوقية محددة:** استهداف شرائح سوقية محددة والتركيز على تلبية احتياجاتها بشكل أفضل من المنافسين.
+        3. **تطوير علاقات قوية مع العملاء:** تطوير علاقات قوية مع العملاء لضمان ولائهم وتكرار التعامل معهم.
+        4. **الابتكار في الخدمات والحلول:** تقديم حلول مبتكرة وخدمات متميزة تلبي احتياجات العملاء بشكل أفضل من المنافسين.
+        5. **تحسين الكفاءة التشغيلية:** تحسين الكفاءة التشغيلية لتقليل التكاليف وزيادة القدرة التنافسية.
+        6. **بناء تحالفات استراتيجية:** بناء تحالفات استراتيجية مع شركات أخرى لتعزيز القدرة التنافسية.
+        7. **مراقبة المنافسين باستمرار:** مراقبة المنافسين باستمرار وتحليل استراتيجياتهم وتحركاتهم في السوق.
+        """)
+    
+    def _render_import_export_tab(self):
+        """عرض تبويب استيراد وتصدير البيانات"""
+        
+        st.markdown("### استيراد وتصدير البيانات")
+        
+        # عرض مصادر البيانات الحالية
+        st.markdown("#### مصادر البيانات الحالية")
+        
+        # تحويل قائمة مصادر البيانات إلى DataFrame
+        sources_df = pd.DataFrame(st.session_state.data_sources)
+        
+        # عرض مصادر البيانات كجدول
+        st.dataframe(
+            sources_df,
+            column_config={
+                "id": st.column_config.NumberColumn("الرقم"),
+                "name": st.column_config.TextColumn("اسم المصدر"),
+                "type": st.column_config.TextColumn("النوع"),
+                "rows": st.column_config.NumberColumn("عدد الصفوف"),
+                "columns": st.column_config.NumberColumn("عدد الأعمدة"),
+                "last_updated": st.column_config.DateColumn("تاريخ التحديث"),
+                "description": st.column_config.TextColumn("الوصف")
+            },
+            use_container_width=True,
+            hide_index=True
+        )
+        
+        # استيراد بيانات جديدة
+        st.markdown("#### استيراد بيانات جديدة")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            data_type = st.selectbox(
+                "نوع البيانات",
+                ["بيانات المناقصات", "بيانات المنافسين", "بيانات أسعار المواد", "بيانات الموردين", "بيانات المشاريع", "أخرى"]
+            )
+        
+        with col2:
+            file_format = st.selectbox(
+                "صيغة الملف",
+                ["CSV", "Excel", "JSON"]
+            )
+        
+        uploaded_file = st.file_uploader(f"قم بتحميل ملف {file_format}", type=["csv", "xlsx", "json"])
+        
+        if uploaded_file is not None:
+            if st.button("استيراد البيانات"):
+                # محاكاة استيراد البيانات
+                with st.spinner("جاري استيراد البيانات..."):
+                    time.sleep(2)  # محاكاة وقت المعالجة
+                    
+                    # تحديث قائمة مصادر البيانات
+                    new_id = max([source["id"] for source in st.session_state.data_sources]) + 1
+                    
+                    st.session_state.data_sources.append({
+                        "id": new_id,
+                        "name": f"{data_type} - {uploaded_file.name}",
+                        "type": file_format,
+                        "rows": np.random.randint(50, 500),
+                        "columns": np.random.randint(5, 20),
+                        "last_updated": time.strftime("%Y-%m-%d"),
+                        "description": f"بيانات تم استيرادها من ملف {uploaded_file.name}"
+                    })
+                    
+                    st.success("تم استيراد البيانات بنجاح!")
+                    st.rerun()
+        
+        # تصدير البيانات
+        st.markdown("#### تصدير البيانات")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            export_data_type = st.selectbox(
+                "نوع البيانات للتصدير",
+                ["بيانات المناقصات", "بيانات المنافسين", "ب��انات أسعار المواد", "بيانات الموردين", "بيانات المشاريع", "تقرير تحليلي شامل"]
+            )
+        
+        with col2:
+            export_format = st.selectbox(
+                "صيغة التصدير",
+                ["CSV", "Excel", "JSON", "PDF"]
+            )
+        
+        if st.button("تصدير البيانات"):
+            # محاكاة تصدير البيانات
+            with st.spinner("جاري تصدير البيانات..."):
+                time.sleep(2)  # محاكاة وقت المعالجة
+                st.success(f"تم تصدير {export_data_type} بصيغة {export_format} بنجاح!")
+                
+                # إنشاء رابط تنزيل وهمي
+                if export_data_type == "بيانات المناقصات":
+                    df = st.session_state.sample_data["tenders"]
+                elif export_data_type == "بيانات المنافسين":
+                    df = st.session_state.sample_data["competitors"]
+                elif export_data_type == "بيانات أسعار المواد":
+                    df = st.session_state.sample_data["materials"]
+                else:
+                    # إنشاء DataFrame وهمي للأنواع الأخرى
+                    df = pd.DataFrame({
+                        "البيان": ["بيان 1", "بيان 2", "بيان 3"],
+                        "القيمة": [100, 200, 300]
+                    })
+                
+                # تحويل DataFrame إلى CSV
+                csv = df.to_csv(index=False)
+                b64 = base64.b64encode(csv.encode()).decode()
+                href = f'<a href="data:file/csv;base64,{b64}" download="{export_data_type}.csv">انقر هنا لتنزيل الملف</a>'
+                st.markdown(href, unsafe_allow_html=True)
+        
+        # تكامل البيانات مع الوحدات الأخرى
+        st.markdown("#### تكامل البيانات مع الوحدات الأخرى")
+        
+        st.markdown("""
+        يمكن تكامل البيانات مع الوحدات الأخرى في النظام من خلال:
+        
+        1. **إرسال البيانات إلى وحدة التسعير:** إرسال بيانات أسعار المواد وبيانات المناقصات السابقة إلى وحدة التسعير لتحسين دقة التسعير.
+        2. **إرسال البيانات إلى وحدة تحليل المخاطر:** إرسال بيانات المناقصات السابقة وبيانات المنافسين إلى وحدة تحليل المخاطر لتحسين تقييم المخاطر.
+        3. **إرسال البيانات إلى وحدة الذكاء الاصطناعي:** إرسال البيانات إلى وحدة الذكاء الاصطناعي لتدريب النماذج وتحسين دقة التنبؤات.
+        4. **إرسال البيانات إلى وحدة إدارة المشاريع:** إرسال بيانات المشاريع المنجزة إلى وحدة إدارة المشاريع لتحسين تخطيط وإدارة المشاريع المستقبلية.
+        5. **إرسال البيانات إلى وحدة التقارير:** إرسال البيانات إلى وحدة التقارير لإنشاء تقارير تحليلية شاملة.
+        """)
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            if st.button("إرسال إلى وحدة التسعير"):
+                st.success("تم إرسال البيانات إلى وحدة التسعير بنجاح!")
+        
+        with col2:
+            if st.button("إرسال إلى وحدة تحليل المخاطر"):
+                st.success("تم إرسال البيانات إلى وحدة تحليل المخاطر بنجاح!")
+        
+        with col3:
+            if st.button("إرسال إلى وحدة الذكاء الاصطناعي"):
+                st.success("تم إرسال البيانات إلى وحدة الذكاء الاصطناعي بنجاح!")

modules/document_analysis/analyzer.py

@@ -0,0 +1,281 @@
+"""
+وحدة تحليل المستندات لنظام إدارة المناقصات - Hybrid Face
+"""
+
+import os
+import re
+import logging
+import threading
+from pathlib import Path
+import datetime
+import json
+
+# تهيئة السجل
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger('document_analysis')
+
+class DocumentAnalyzer:
+    """فئة تحليل المستندات"""
+    
+    def __init__(self, config=None):
+        """تهيئة محلل المستندات"""
+        self.config = config
+        self.analysis_in_progress = False
+        self.current_document = None
+        self.analysis_results = {}
+        
+        # إنشاء مجلد المستندات إذا لم يكن موجوداً
+        if config and hasattr(config, 'DOCUMENTS_PATH'):
+            self.documents_path = Path(config.DOCUMENTS_PATH)
+        else:
+            self.documents_path = Path('data/documents')
+            
+        if not self.documents_path.exists():
+            self.documents_path.mkdir(parents=True, exist_ok=True)
+    
+    def analyze_document(self, document_path, document_type="tender", callback=None):
+        """تحليل مستند"""
+        if self.analysis_in_progress:
+            logger.warning("هناك عملية تحليل جارية بالفعل")
+            return False
+        
+        if not os.path.exists(document_path):
+            logger.error(f"المستند غير موجود: {document_path}")
+            return False
+        
+        self.analysis_in_progress = True
+        self.current_document = document_path
+        self.analysis_results = {
+            "document_path": document_path,
+            "document_type": document_type,
+            "analysis_start_time": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+            "status": "جاري التحليل",
+            "items": [],
+            "entities": [],
+            "dates": [],
+            "amounts": [],
+            "risks": []
+        }
+        
+        # بدء التحليل في خيط منفصل
+        thread = threading.Thread(
+            target=self._analyze_document_thread,
+            args=(document_path, document_type, callback)
+        )
+        thread.daemon = True
+        thread.start()
+        
+        return True
+    
+    def _analyze_document_thread(self, document_path, document_type, callback):
+        """خيط تحليل المستند"""
+        try:
+            # تحديد نوع المستند
+            file_extension = os.path.splitext(document_path)[1].lower()
+            
+            if file_extension == '.pdf':
+                self._analyze_pdf(document_path, document_type)
+            elif file_extension == '.docx':
+                self._analyze_docx(document_path, document_type)
+            elif file_extension == '.xlsx':
+                self._analyze_xlsx(document_path, document_type)
+            elif file_extension == '.txt':
+                self._analyze_txt(document_path, document_type)
+            else:
+                logger.error(f"نوع المستند غير مدعوم: {file_extension}")
+                self.analysis_results["status"] = "فشل التحليل"
+                self.analysis_results["error"] = "نوع المستند غير مدعوم"
+            
+            # تحديث حالة التحليل
+            if self.analysis_results["status"] != "فشل التحليل":
+                self.analysis_results["status"] = "اكتمل التحليل"
+                self.analysis_results["analysis_end_time"] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            
+            logger.info(f"اكتمل تحليل المستند: {document_path}")
+            
+        except Exception as e:
+            logger.error(f"خطأ في تحليل المستند: {str(e)}")
+            self.analysis_results["status"] = "فشل التحليل"
+            self.analysis_results["error"] = str(e)
+        
+        finally:
+            self.analysis_in_progress = False
+            
+            # استدعاء دالة الاستجابة إذا تم توفيرها
+            if callback and callable(callback):
+                callback(self.analysis_results)
+    
+    def _analyze_pdf(self, document_path, document_type):
+        """تحليل مستند PDF"""
+        try:
+            # محاكاة تحليل مستند PDF
+            logger.info(f"تحليل مستند PDF: {document_path}")
+            
+            # في التطبيق الفعلي، سيتم استخدام مكتبة مثل PyPDF2 أو pdfplumber
+            # لاستخراج النص من ملف PDF وتحليله
+            
+            # محاكاة استخراج البنود
+            self.analysis_results["items"] = [
+                {"id": 1, "name": "أعمال الحفر", "description": "حفر وإزالة التربة", "unit": "م³", "estimated_quantity": 1500},
+                {"id": 2, "name": "أعمال الخرسانة", "description": "صب خرسانة مسلحة", "unit": "م³", "estimated_quantity": 750},
+                {"id": 3, "name": "أعمال الأسفلت", "description": "تمهيد وفرش طبقة أسفلت", "unit": "م²", "estimated_quantity": 5000}
+            ]
+            
+            # محاكاة استخراج الكيانات
+            self.analysis_results["entities"] = [
+                {"type": "client", "name": "وزارة النقل", "mentions": 5},
+                {"type": "location", "name": "المنطقة الشرقية", "mentions": 3},
+                {"type": "contractor", "name": "شركة المقاولات المتحدة", "mentions": 2}
+            ]
+            
+            # محاكاة استخراج التواريخ
+            self.analysis_results["dates"] = [
+                {"type": "start_date", "date": "2025-05-01", "description": "تاريخ بدء المشروع"},
+                {"type": "end_date", "date": "2025-11-30", "description": "تاريخ انتهاء المشروع"},
+                {"type": "submission_date", "date": "2025-04-15", "description": "تاريخ تقديم العروض"}
+            ]
+            
+            # محاكاة استخراج المبالغ
+            self.analysis_results["amounts"] = [
+                {"type": "estimated_cost", "amount": 5000000, "currency": "SAR", "description": "التكلفة التقديرية للمشروع"},
+                {"type": "advance_payment", "amount": 500000, "currency": "SAR", "description": "الدفعة المقدمة (10%)"},
+                {"type": "performance_bond", "amount": 250000, "currency": "SAR", "description": "ضمان حسن التنفيذ (5%)"}
+            ]
+            
+            # محاكاة استخراج المخاطر
+            self.analysis_results["risks"] = [
+                {"type": "delay_risk", "description": "مخاطر التأخير في التنفيذ", "probability": "متوسط", "impact": "عالي"},
+                {"type": "cost_risk", "description": "مخاطر زيادة التكاليف", "probability": "عالي", "impact": "عالي"},
+                {"type": "quality_risk", "description": "مخاطر جودة التنفيذ", "probability": "منخفض", "impact": "متوسط"}
+            ]
+            
+        except Exception as e:
+            logger.error(f"خطأ في تحليل مستند PDF: {str(e)}")
+            raise
+    
+    def _analyze_docx(self, document_path, document_type):
+        """تحليل مستند Word"""
+        try:
+            # محاكاة تحليل مستند Word
+            logger.info(f"تحليل مستند Word: {document_path}")
+            
+            # في التطبيق الفعلي، سيتم استخدام مكتبة مثل python-docx
+            # لاستخراج النص من ملف Word وتحليله
+            
+            # محاكاة استخراج البنود والكيانات والتواريخ والمبالغ والمخاطر
+            # (مشابه لتحليل PDF)
+            self.analysis_results["items"] = [
+                {"id": 1, "name": "توريد معدات", "description": "توريد معدات المشروع", "unit": "مجموعة", "estimated_quantity": 10},
+                {"id": 2, "name": "تركيب المعدات", "description": "تركيب وتشغيل المعدات", "unit": "مجموعة", "estimated_quantity": 10},
+                {"id": 3, "name": "التدريب", "description": "تدريب الموظفين على استخدام المعدات", "unit": "يوم", "estimated_quantity": 20}
+            ]
+            
+            # محاكاة استخراج الكيانات والتواريخ والمبالغ والمخاطر
+            # (مشابه لتحليل PDF)
+            
+        except Exception as e:
+            logger.error(f"خطأ في تحليل مستند Word: {str(e)}")
+            raise
+    
+    def _analyze_xlsx(self, document_path, document_type):
+        """تحليل مستند Excel"""
+        try:
+            # محاكاة تحليل مستند Excel
+            logger.info(f"تحليل مستند Excel: {document_path}")
+            
+            # في التطبيق الفعلي، سيتم استخدام مكتبة مثل pandas أو openpyxl
+            # لاستخراج البيانات من ملف Excel وتحليلها
+            
+            # محاكاة استخراج البنود
+            self.analysis_results["items"] = [
+                {"id": 1, "name": "بند 1", "description": "وصف البند 1", "unit": "وحدة", "estimated_quantity": 100},
+                {"id": 2, "name": "بند 2", "description": "وصف البند 2", "unit": "وحدة", "estimated_quantity": 200},
+                {"id": 3, "name": "بند 3", "description": "وصف البند 3", "unit": "وحدة", "estimated_quantity": 300}
+            ]
+            
+            # محاكاة استخراج المبالغ
+            self.analysis_results["amounts"] = [
+                {"type": "item_cost", "amount": 10000, "currency": "SAR", "description": "تكلفة البند 1"},
+                {"type": "item_cost", "amount": 20000, "currency": "SAR", "description": "تكلفة البند 2"},
+                {"type": "item_cost", "amount": 30000, "currency": "SAR", "description": "تكلفة البند 3"}
+            ]
+            
+        except Exception as e:
+            logger.error(f"خطأ في تحليل مستند Excel: {str(e)}")
+            raise
+    
+    def _analyze_txt(self, document_path, document_type):
+        """تحليل مستند نصي"""
+        try:
+            # محاكاة تحليل مستند نصي
+            logger.info(f"تحليل مستند نصي: {document_path}")
+            
+            # في التطبيق الفعلي، سيتم قراءة الملف النصي وتحليله
+            
+            # محاكاة استخراج البنود والكيانات والتواريخ والمبالغ والمخاطر
+            # (مشابه للتحليلات الأخرى)
+            
+        except Exception as e:
+            logger.error(f"خطأ في تحليل مستند نصي: {str(e)}")
+            raise
+    
+    def get_analysis_status(self):
+        """الحصول على حالة التحليل الحالي"""
+        if not self.analysis_in_progress:
+            if not self.analysis_results:
+                return {"status": "لا يوجد تحليل جارٍ"}
+            else:
+                return {"status": self.analysis_results.get("status", "غير معروف")}
+        
+        return {
+            "status": "جاري التحليل",
+            "document_path": self.current_document,
+            "start_time": self.analysis_results.get("analysis_start_time")
+        }
+    
+    def get_analysis_results(self):
+        """الحصول على نتائج التحليل"""
+        return self.analysis_results
+    
+    def export_analysis_results(self, output_path=None):
+        """تصدير نتائج التحليل إلى ملف JSON"""
+        if not self.analysis_results:
+            logger.warning("لا توجد نتائج تحليل للتصدير")
+            return None
+        
+        if not output_path:
+            # إنشاء اسم ملف افتراضي
+            timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+            filename = f"analysis_results_{timestamp}.json"
+            output_path = os.path.join(self.documents_path, filename)
+        
+        try:
+            with open(output_path, 'w', encoding='utf-8') as f:
+                json.dump(self.analysis_results, f, ensure_ascii=False, indent=4)
+            
+            logger.info(f"تم تصدير نتائج التحليل إلى: {output_path}")
+            return output_path
+        
+        except Exception as e:
+            logger.error(f"خطأ في تصدير نتائج التحليل: {str(e)}")
+            return None
+    
+    def import_analysis_results(self, input_path):
+        """استيراد نتائج التحليل من ملف JSON"""
+        if not os.path.exists(input_path):
+            logger.error(f"ملف نتائج التحليل غير موجود: {input_path}")
+            return False
+        
+        try:
+            with open(input_path, 'r', encoding='utf-8') as f:
+                self.analysis_results = json.load(f)
+            
+            logger.info(f"تم استيراد نتائج التحليل من: {input_path}")
+            return True
+        
+        except Exception as e:
+            logger.error(f"خطأ في استيراد نتائج التحليل: {str(e)}")
+            return False

modules/document_analysis/document_app.py

@@ -0,0 +1,887 @@
+"""
+وحدة تحليل المستندات - التطبيق الرئيسي
+"""
+
+# استيراد المكتبات القياسية
+import os
+import sys
+import logging
+import base64
+import json
+import time
+from io import BytesIO
+from pathlib import Path
+from urllib.parse import urlparse
+from tempfile import NamedTemporaryFile
+
+# استيراد مكتبة Streamlit
+import streamlit as st
+
+# استيراد المكتبات الإضافية
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import plotly.express as px
+import plotly.graph_objects as go
+import requests
+from PIL import Image
+
+# محاولة استيراد خدمات تحليل المستندات
+try:
+    from .services.text_extractor import TextExtractor
+    from .services.item_extractor import ItemExtractor
+    from .services.document_parser import DocumentParser
+except ImportError:
+    try:
+        from modules.document_analysis.services.text_extractor import TextExtractor
+        from modules.document_analysis.services.item_extractor import ItemExtractor
+        from modules.document_analysis.services.document_parser import DocumentParser
+    except ImportError:
+        # تعريف فئات وهمية في حالة عدم وجود الخدمات
+        class TextExtractor:
+            def __init__(self, config=None):
+                self.config = config or {}
+                
+            def extract_from_pdf(self, file_path):
+                return "نص مستخرج مؤقت من PDF"
+                
+            def extract_from_docx(self, file_path):
+                return "نص مستخرج مؤقت من DOCX"
+                
+            def extract_from_image(self, file_path):
+                return "نص مستخرج مؤقت من صورة"
+                
+            def extract(self, file_path):
+                _, ext = os.path.splitext(file_path)
+                ext = ext.lower()
+                
+                if ext == '.pdf':
+                    return self.extract_from_pdf(file_path)
+                elif ext in ('.doc', '.docx'):
+                    return self.extract_from_docx(file_path)
+                elif ext in ('.jpg', '.jpeg', '.png'):
+                    return self.extract_from_image(file_path)
+                else:
+                    return "نوع ملف غير مدعوم"
+        
+        class ItemExtractor:
+            def __init__(self, config=None):
+                self.config = config or {}
+                
+            def extract_tables(self, document):
+                return [{"عنوان": "جدول مؤقت", "بيانات": []}]
+                
+            def extract_items(self, document):
+                return [
+                    {"رقم البند": "A1", "وصف البند": "توريد وتركيب أعمال الخرسانة المسلحة للأساسات", "الوحدة": "م3", "الكمية": 250.0},
+                    {"رقم البند": "A2", "وصف البند": "توريد وتركيب حديد التسليح للأساسات", "الوحدة": "طن", "الكمية": 25.0},
+                    {"رقم البند": "A3", "وصف البند": "أعمال العزل المائي للأساسات", "الوحدة": "م2", "الكمية": 500.0}
+                ]
+        
+        class DocumentParser:
+            def __init__(self, config=None):
+                self.config = config or {}
+                
+            def parse_document(self, file_path):
+                return {
+                    "metadata": {
+                        "title": "مستند مؤقت",
+                        "author": "غير معروف",
+                        "date": "2024-01-01",
+                        "pages": 10
+                    },
+                    "content": "محتوى مؤقت للمستند",
+                    "tables": [],
+                    "items": []
+                }
+                
+            def extract_metadata(self, file_path):
+                return {
+                    "title": "مستند مؤقت",
+                    "author": "غير معروف",
+                    "date": "2024-01-01",
+                    "pages": 10
+                }
+
+
+class DocumentAnalysisApp:
+    """وحدة تحليل المستندات"""
+    
+    def __init__(self):
+        """تهيئة وحدة تحليل المستندات"""
+        
+        # تهيئة خدمات تحليل المستندات
+        self.text_extractor = TextExtractor()
+        self.item_extractor = ItemExtractor()
+        self.document_parser = DocumentParser()
+        
+        # تهيئة حالة الجلسة
+        if 'analyzed_documents' not in st.session_state:
+            st.session_state.analyzed_documents = []
+        
+        if 'extracted_items' not in st.session_state:
+            st.session_state.extracted_items = []
+        
+        # إنشاء مجلد مؤقت للملفات
+        self.temp_dir = Path("temp_documents")
+        self.temp_dir.mkdir(exist_ok=True)
+    
+    def render(self):
+        """عرض واجهة وحدة تحليل المستندات"""
+        
+        st.markdown("<h1 class='module-title'>وحدة تحليل المستندات</h1>", unsafe_allow_html=True)
+        
+        tabs = st.tabs([
+            "تحليل المستندات", 
+            "استخراج البنود والكميات",
+            "تحليل الصور والمخططات",
+            "مكتبة المستندات",
+            "الإعدادات"
+        ])
+        
+        with tabs[0]:
+            self._render_document_analysis_tab()
+        
+        with tabs[1]:
+            self._render_item_extraction_tab()
+        
+        with tabs[2]:
+            self._render_image_analysis_tab()
+        
+        with tabs[3]:
+            self._render_document_library_tab()
+        
+        with tabs[4]:
+            self._render_settings_tab()
+    
+    def _render_document_analysis_tab(self):
+        """عرض تبويب تحليل المستندات"""
+        
+        st.markdown("### تحليل المستندات")
+        
+        # رفع المستند
+        uploaded_file = st.file_uploader("رفع مستند للتحليل", type=["pdf", "docx", "txt", "jpg", "jpeg", "png"], key="document_upload")
+        
+        if uploaded_file is not None:
+            # حفظ الملف مؤقتاً
+            file_path = self._save_uploaded_file(uploaded_file)
+            
+            if file_path:
+                st.success(f"تم رفع الملف: {uploaded_file.name}")
+                
+                # عرض معلومات الملف
+                file_info = self._get_file_info(file_path)
+                
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    st.metric("نوع الملف", file_info["type"])
+                
+                with col2:
+                    st.metric("حجم الملف", file_info["size"])
+                
+                with col3:
+                    if "pages" in file_info:
+                        st.metric("عدد الصفحات", file_info["pages"])
+                
+                # خيارات التحليل
+                analysis_options = st.multiselect(
+                    "اختر خيارات التحليل",
+                    [
+                        "استخراج النص",
+                        "استخراج الجداول",
+                        "استخراج البنود والكميات",
+                        "استخراج المعلومات الرئيسية",
+                        "تحليل هيكل المستند"
+                    ],
+                    default=["استخراج النص", "استخراج البنود والكميات"],
+                    key="analysis_options"
+                )
+                
+                # زر بدء التحليل
+                if st.button("بدء التحليل", key="start_analysis_button"):
+                    with st.spinner("جاري تحليل المستند..."):
+                        # محاكاة وقت التحليل
+                        time.sleep(2)
+                        
+                        # تنفيذ التحليل المطلوب
+                        analysis_results = {}
+                        
+                        if "استخراج النص" in analysis_options:
+                            analysis_results["text"] = self.text_extractor.extract(file_path)
+                        
+                        if "استخراج الجداول" in analysis_options:
+                            # محاكاة استخراج الجداول
+                            tables = self.item_extractor.extract_tables(file_path)
+                            analysis_results["tables"] = tables
+                        
+                        if "استخراج البنود والكميات" in analysis_options:
+                            # محاكاة استخراج البنود
+                            items = self.item_extractor.extract_items(file_path)
+                            analysis_results["items"] = items
+                            
+                            # حفظ البنود المستخرجة في حالة الجلسة
+                            st.session_state.extracted_items = items
+                        
+                        if "استخراج المعلومات الرئيسية" in analysis_options:
+                            # محاكاة استخراج المعلومات الرئيسية
+                            metadata = self.document_parser.extract_metadata(file_path)
+                            analysis_results["metadata"] = metadata
+                        
+                        if "تحليل هيكل المستند" in analysis_options:
+                            # محاكاة تحليل هيكل المستند
+                            structure = {
+                                "sections": [
+                                    {"title": "مقدمة", "level": 1, "page": 1},
+                                    {"title": "نطاق العمل", "level": 1, "page": 2},
+                                    {"title": "المواصفات الفنية", "level": 1, "page": 3},
+                                    {"title": "جدول الكميات", "level": 1, "page": 5},
+                                    {"title": "الشروط الخاصة", "level": 1, "page": 7}
+                                ]
+                            }
+                            analysis_results["structure"] = structure
+                        
+                        # حفظ نتائج التحليل في حالة الجلسة
+                        st.session_state.analyzed_documents.append({
+                            "file_name": uploaded_file.name,
+                            "file_path": str(file_path),
+                            "analysis_options": analysis_options,
+                            "results": analysis_results,
+                            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
+                        })
+                    
+                    st.success("تم الانتهاء من تحليل المستند!")
+                    
+                    # عرض نتائج التحليل
+                    self._display_analysis_results(analysis_results)
+        
+        # عرض سجل التحليلات السابقة
+        if st.session_state.analyzed_documents:
+            st.markdown("### سجل التحليلات السابقة")
+            
+            for i, doc in enumerate(reversed(st.session_state.analyzed_documents)):
+                with st.expander(f"{doc['file_name']} ({doc['timestamp']})"):
+                    st.markdown(f"**خيارات التحليل:** {', '.join(doc['analysis_options'])}")
+                    
+                    # عرض نتائج التحليل
+                    self._display_analysis_results(doc['results'])
+                    
+                    # أزرار العمليات
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        if st.button("إرسال إلى وحدة التسعير", key=f"send_to_pricing_{i}"):
+                            st.success("تم إرسال البيانات إلى وحدة التسعير بنجاح!")
+                    
+                    with col2:
+                        if st.button("تصدير النتائج", key=f"export_results_{i}"):
+                            st.success("تم تصدير النتائج بنجاح!")
+    
+    def _render_item_extraction_tab(self):
+        """عرض تبويب استخراج البنود والكميات"""
+        
+        st.markdown("### استخراج البنود والكميات")
+        
+        # التحقق من وجود بنود مستخرجة
+        if not st.session_state.extracted_items:
+            st.warning("لا توجد بنود مستخرجة. يرجى تحليل مستند أولاً.")
+            
+            # عرض بيانات افتراضية للتوضيح
+            st.markdown("### مثال توضيحي")
+            
+            # بيانات افتراضية
+            sample_items = [
+                {"رقم البند": "A1", "وصف البند": "توريد وتركيب أعمال الخرسانة المسلحة للأساسات", "الوحدة": "م3", "الكمية": 250.0},
+                {"رقم البند": "A2", "وصف البند": "توريد وتركيب حديد التسليح للأساسات", "الوحدة": "طن", "الكمية": 25.0},
+                {"رقم البند": "A3", "وصف البند": "أعمال العزل المائي للأساسات", "الوحدة": "م2", "الكمية": 500.0},
+                {"رقم البند": "A4", "وصف البند": "أعمال الردم والدك للأساسات", "الوحدة": "م3", "الكمية": 300.0},
+                {"رقم البند": "A5", "وصف البند": "توريد وتركيب أعمال الخرسانة المسلحة للأعمدة", "الوحدة": "م3", "الكمية": 120.0}
+            ]
+            
+            # عرض البنود كجدول
+            items_df = pd.DataFrame(sample_items)
+            st.dataframe(items_df, use_container_width=True, hide_index=True)
+            
+            # زر لاستخدام البيانات التوضيحية
+            if st.button("استخدام البيانات التوضيحية", key="use_sample_data_button"):
+                st.session_state.extracted_items = sample_items
+                st.success("تم استخدام البيانات التوضيحية!")
+                st.rerun()
+        else:
+            # عرض البنود المستخرجة
+            items_df = pd.DataFrame(st.session_state.extracted_items)
+            
+            # إضافة عمود سعر الوحدة والإجمالي إذا لم يكن موجوداً
+            if "سعر الوحدة" not in items_df.columns:
+                items_df["سعر الوحدة"] = 0.0
+            
+            if "الإجمالي" not in items_df.columns:
+                items_df["الإجمالي"] = 0.0
+            
+            # عرض البنود كجدول قابل للتعديل
+            st.markdown("### البنود المستخرجة")
+            edited_df = st.data_editor(items_df, use_container_width=True, hide_index=True, key="items_editor")
+            
+            # تحديث البنود المستخرجة بعد التعديل
+            st.session_state.extracted_items = edited_df.to_dict('records')
+            
+            # أزرار العمليات
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                if st.button("إرسال إلى وحدة التسعير", key="send_to_pricing_button"):
+                    # محاكاة إرسال البيانات إلى وحدة التسعير
+                    if 'current_pricing' not in st.session_state:
+                        st.session_state.current_pricing = {
+                            'name': "مناقصة جديدة",
+                            'number': "T-" + time.strftime("%Y-%m-%d"),
+                            'client': "",
+                            'location': "",
+                            'method': "التسعير القياسي",
+                            'submission_date': None,
+                            'items': edited_df,
+                            'status': 'جديد',
+                            'created_at': time.strftime("%Y-%m-%d %H:%M:%S")
+                        }
+                    else:
+                        st.session_state.current_pricing['items'] = edited_df
+                    
+                    st.success("تم إرسال البنود إلى وحدة التسعير بنجاح!")
+            
+            with col2:
+                if st.button("تصدير إلى Excel", key="export_to_excel_button"):
+                    st.success("تم تصدير البنود إلى Excel بنجاح!")
+            
+            with col3:
+                if st.button("مسح البنود", key="clear_items_button"):
+                    st.session_state.extracted_items = []
+                    st.warning("تم مسح البنود!")
+                    st.rerun()
+            
+            # عرض إحصائيات البنود
+            st.markdown("### إحصائيات البنود")
+            
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                st.metric("عدد البنود", len(edited_df))
+            
+            with col2:
+                units_count = edited_df['الوحدة'].value_counts()
+                most_common_unit = units_count.index[0] if not units_count.empty else "غير متوفر"
+                st.metric("الوحدة الأكثر استخداماً", most_common_unit)
+            
+            with col3:
+                total_quantity = edited_df['الكمية'].sum()
+                st.metric("إجمالي الكميات", f"{total_quantity:,.2f}")
+            
+            # رسم بياني لتوزيع البنود حسب الوحدة
+            st.markdown("### توزيع البنود حسب الوحدة")
+            
+            units_df = pd.DataFrame(units_count).reset_index()
+            units_df.columns = ['الوحدة', 'العدد']
+            
+            fig = px.pie(
+                units_df,
+                values='العدد',
+                names='الوحدة',
+                title='توزيع البنود حسب الوحدة',
+                hole=0.4
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_image_analysis_tab(self):
+        """عرض تبويب تحليل الصور والمخططات"""
+        
+        st.markdown("### تحليل الصور والمخططات")
+        
+        # رفع الصورة
+        uploaded_image = st.file_uploader("رفع صورة أو مخطط للتحليل", type=["jpg", "jpeg", "png", "tif", "tiff"], key="image_upload")
+        
+        if uploaded_image is not None:
+            # عرض الصورة
+            image = Image.open(uploaded_image)
+            st.image(image, caption=uploaded_image.name, use_column_width=True)
+            
+            # خيارات التحليل
+            analysis_type = st.selectbox(
+                "نوع التحليل",
+                [
+                    "استخراج النص من الصورة",
+                    "تحليل المخططات الهندسية",
+                    "قياس المساحات والأبعاد",
+                    "تحليل مخصص"
+                ],
+                key="image_analysis_type"
+            )
+            
+            # زر بدء التحليل
+            if st.button("بدء التحليل", key="start_image_analysis_button"):
+                with st.spinner("جاري تحليل الصورة..."):
+                    # محاكاة وقت التحليل
+                    time.sleep(2)
+                    
+                    if analysis_type == "استخراج النص من الصورة":
+                        # محاكاة استخراج النص
+                        extracted_text = "نص مستخرج من الصورة (محاكاة):\n\n"
+                        extracted_text += "مواصفات المشروع:\n"
+                        extracted_text += "- مساحة الأرض: 1000 م2\n"
+                        extracted_text += "- عدد الطوابق: 3\n"
+                        extracted_text += "- ارتفاع المبنى: 12 م\n"
+                        
+                        st.markdown("### النص المستخرج من الصورة")
+                        st.text_area("النص المستخرج", extracted_text, height=200)
+                    
+                    elif analysis_type == "تحليل المخططات الهندسية":
+                        # محاكاة تحليل المخططات
+                        st.markdown("### نتائج تحليل المخطط الهندسي")
+                        
+                        # محاكاة رسم تخطيطي للمخطط
+                        fig, ax = plt.subplots(figsize=(10, 6))
+                        ax.imshow(image)
+                        
+                        # إضافة تعليقات توضيحية
+                        ax.annotate('غرفة المعيشة', xy=(100, 100), xytext=(150, 50),
+                                    arrowprops=dict(facecolor='red', shrink=0.05))
+                        
+                        ax.annotate('المطبخ', xy=(300, 150), xytext=(350, 100),
+                                    arrowprops=dict(facecolor='blue', shrink=0.05))
+                        
+                        ax.annotate('غرفة النوم', xy=(200, 300), xytext=(250, 350),
+                                    arrowprops=dict(facecolor='green', shrink=0.05))
+                        
+                        st.pyplot(fig)
+                        
+                        # عرض معلومات المخطط
+                        st.markdown("### معلومات المخطط")
+                        
+                        col1, col2, col3 = st.columns(3)
+                        
+                        with col1:
+                            st.metric("المساحة الإجمالية", "150 م2")
+                        
+                        with col2:
+                            st.metric("عدد الغرف", "3")
+                        
+                        with col3:
+                            st.metric("عدد الحمامات", "2")
+                    
+                    elif analysis_type == "قياس المساحات والأبعاد":
+                        # محاكاة قياس المساحات
+                        st.markdown("### نتائج قياس المساحات والأبعاد")
+                        
+                        # محاكاة رسم تخطيطي للمساحات
+                        fig, ax = plt.subplots(figsize=(10, 6))
+                        ax.imshow(image)
+                        
+                        # إضافة قياسات
+                        ax.plot([50, 250], [50, 50], 'r-', linewidth=2)
+                        ax.text(150, 40, '10 م', color='red', fontsize=12, ha='center')
+                        
+                        ax.plot([50, 50], [50, 250], 'b-', linewidth=2)
+                        ax.text(40, 150, '8 م', color='blue', fontsize=12, va='center', rotation=90)
+                        
+                        st.pyplot(fig)
+                        
+                        # عرض جدول القياسات
+                        measurements = pd.DataFrame({
+                            'العنصر': ['الطول', 'العرض', 'المساحة', 'المحيط'],
+                            'القيمة': ['10 م', '8 م', '80 م2', '36 م']
+                        })
+                        
+                        st.dataframe(measurements, use_container_width=True, hide_index=True)
+                    
+                    else:  # تحليل مخصص
+                        st.markdown("### نتائج التحليل المخصص")
+                        st.info("تم تحليل الصورة بنجاح. يمكنك تخصيص التحليل حسب احتياجاتك.")
+                
+                # خيارات التصدير
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    if st.button("تصدير نتائج التحليل", key="export_image_analysis_button"):
+                        st.success("تم تصدير نتائج التحليل بنجاح!")
+                
+                with col2:
+                    if st.button("إرسال إلى وحدة التسعير", key="send_image_to_pricing_button"):
+                        st.success("تم إرسال نت��ئج التحليل إلى وحدة التسعير بنجاح!")
+    
+    def _render_document_library_tab(self):
+        """عرض تبويب مكتبة المستندات"""
+        
+        st.markdown("### مكتبة المستندات")
+        
+        # بيانات افتراضية للمستندات
+        if 'document_library' not in st.session_state:
+            st.session_state.document_library = [
+                {
+                    "id": 1,
+                    "name": "كراسة شروط مشروع توسعة مستشفى الملك فهد",
+                    "type": "PDF",
+                    "size": "5.2 MB",
+                    "pages": 120,
+                    "upload_date": "2024-01-15",
+                    "category": "كراسات الشروط",
+                    "tags": ["صحي", "مستشفى", "توسعة"]
+                },
+                {
+                    "id": 2,
+                    "name": "جدول كميات صيانة محطات المياه",
+                    "type": "Excel",
+                    "size": "1.8 MB",
+                    "pages": None,
+                    "upload_date": "2024-02-10",
+                    "category": "جداول الكميات",
+                    "tags": ["مياه", "صيانة", "محطات"]
+                },
+                {
+                    "id": 3,
+                    "name": "مخططات إنشاء مدرسة ثانوية",
+                    "type": "PDF",
+                    "size": "12.5 MB",
+                    "pages": 45,
+                    "upload_date": "2024-02-25",
+                    "category": "مخططات",
+                    "tags": ["تعليم", "مدرسة", "إنشاء"]
+                },
+                {
+                    "id": 4,
+                    "name": "عقد إنشاء طريق دائري",
+                    "type": "Word",
+                    "size": "0.9 MB",
+                    "pages": 28,
+                    "upload_date": "2024-03-05",
+                    "category": "عقود",
+                    "tags": ["طرق", "إنشاء", "دائري"]
+                },
+                {
+                    "id": 5,
+                    "name": "تقرير فني لمشروع تطوير شبكة مياه",
+                    "type": "PDF",
+                    "size": "3.7 MB",
+                    "pages": 65,
+                    "upload_date": "2024-03-15",
+                    "category": "تقارير فنية",
+                    "tags": ["مياه", "شبكة", "تطوير"]
+                }
+            ]
+        
+        # البحث في المكتبة
+        search_query = st.text_input("البحث في المكتبة", key="library_search")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            category_filter = st.selectbox(
+                "تصفية حسب الفئة",
+                ["الكل", "كراسات الشروط", "جداول الكميات", "مخططات", "عقود", "تقارير فنية"],
+                key="category_filter"
+            )
+        
+        with col2:
+            type_filter = st.selectbox(
+                "تصفية حسب النوع",
+                ["الكل", "PDF", "Word", "Excel", "Image"],
+                key="type_filter"
+            )
+        
+        with col3:
+            sort_by = st.selectbox(
+                "ترتيب حسب",
+                ["تاريخ الرفع (الأحدث أولاً)", "تاريخ الرفع (الأقدم أولاً)", "الاسم (أ-ي)", "الاسم (ي-أ)", "الحجم (الأكبر أولاً)", "الحجم (الأصغر أولاً)"],
+                key="sort_by"
+            )
+        
+        # تطبيق التصفية والبحث
+        filtered_documents = st.session_state.document_library.copy()
+        
+        # تطبيق البحث
+        if search_query:
+            filtered_documents = [doc for doc in filtered_documents if search_query.lower() in doc["name"].lower() or
+                                 any(search_query.lower() in tag.lower() for tag in doc["tags"])]
+        
+        # تطبيق تصفية الفئة
+        if category_filter != "الكل":
+            filtered_documents = [doc for doc in filtered_documents if doc["category"] == category_filter]
+        
+        # تطبيق تصفية النوع
+        if type_filter != "الكل":
+            filtered_documents = [doc for doc in filtered_documents if doc["type"] == type_filter]
+        
+        # تطبيق الترتيب
+        if sort_by == "تاريخ الرفع (الأحدث أولاً)":
+            filtered_documents.sort(key=lambda x: x["upload_date"], reverse=True)
+        elif sort_by == "تاريخ الرفع (الأقدم أولاً)":
+            filtered_documents.sort(key=lambda x: x["upload_date"])
+        elif sort_by == "الاسم (أ-ي)":
+            filtered_documents.sort(key=lambda x: x["name"])
+        elif sort_by == "الاسم (ي-أ)":
+            filtered_documents.sort(key=lambda x: x["name"], reverse=True)
+        elif sort_by == "الحجم (الأكبر أولاً)":
+            filtered_documents.sort(key=lambda x: float(x["size"].split()[0]), reverse=True)
+        elif sort_by == "الحجم (الأصغر أولاً)":
+            filtered_documents.sort(key=lambda x: float(x["size"].split()[0]))
+        
+        # عرض المستندات
+        st.markdown(f"### المستندات ({len(filtered_documents)})")
+        
+        if not filtered_documents:
+            st.info("لا توجد مستندات تطابق معايير البحث.")
+        else:
+            # عرض المستندات كبطاقات
+            for i, doc in enumerate(filtered_documents):
+                with st.container():
+                    col1, col2, col3 = st.columns([3, 1, 1])
+                    
+                    with col1:
+                        st.markdown(f"**{doc['name']}**")
+                        st.markdown(f"الفئة: {doc['category']} | النوع: {doc['type']} | الحجم: {doc['size']} | تاريخ الرفع: {doc['upload_date']}")
+                        st.markdown(f"الوسوم: {', '.join(doc['tags'])}")
+                    
+                    with col2:
+                        if st.button("عرض", key=f"view_doc_{i}"):
+                            st.session_state.selected_document = doc
+                            st.success(f"جاري عرض المستند: {doc['name']}")
+                    
+                    with col3:
+                        if st.button("تحليل", key=f"analyze_doc_{i}"):
+                            st.session_state.selected_document = doc
+                            st.success(f"جاري تحليل المستند: {doc['name']}")
+                
+                st.markdown("---")
+        
+        # رفع مستند جديد
+        st.markdown("### رفع مستند جديد")
+        
+        uploaded_file = st.file_uploader("اختر ملفاً للرفع", type=["pdf", "docx", "xlsx", "jpg", "jpeg", "png"], key="library_upload")
+        
+        if uploaded_file is not None:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                doc_category = st.selectbox(
+                    "فئة المستند",
+                    ["كراسات الشروط", "جداول الكميات", "مخططات", "عقود", "تقارير فنية", "أخرى"],
+                    key="doc_category"
+                )
+            
+            with col2:
+                doc_tags = st.text_input("الوسوم (مفصولة بفواصل)", key="doc_tags")
+            
+            if st.button("رفع المستند", key="upload_to_library_button"):
+                # محاكاة رفع المستند
+                new_doc = {
+                    "id": len(st.session_state.document_library) + 1,
+                    "name": uploaded_file.name,
+                    "type": uploaded_file.name.split(".")[-1].upper(),
+                    "size": f"{uploaded_file.size / (1024 * 1024):.1f} MB",
+                    "pages": None,
+                    "upload_date": time.strftime("%Y-%m-%d"),
+                    "category": doc_category,
+                    "tags": [tag.strip() for tag in doc_tags.split(",") if tag.strip()]
+                }
+                
+                st.session_state.document_library.append(new_doc)
+                st.success(f"تم رفع المستند: {uploaded_file.name}")
+                st.rerun()
+    
+    def _render_settings_tab(self):
+        """عرض تبويب الإعدادات"""
+        
+        st.markdown("### إعدادات تحليل المستندات")
+        
+        # إعدادات استخراج النص
+        with st.expander("إعدادات استخراج النص", expanded=True):
+            st.markdown("#### إعدادات استخراج النص")
+            
+            ocr_engine = st.selectbox(
+                "محرك التعرف الضوئي على النصوص",
+                ["Tesseract OCR", "Google Cloud Vision", "Amazon Textract", "Microsoft Azure OCR"],
+                index=0,
+                key="ocr_engine"
+            )
+            
+            language = st.selectbox(
+                "لغة المستندات",
+                ["العربية", "الإنجليزية", "العربية والإنجليزية"],
+                index=0,
+                key="ocr_language"
+            )
+            
+            dpi = st.slider(
+                "دقة المسح (DPI)",
+                min_value=100,
+                max_value=600,
+                value=300,
+                step=50,
+                key="ocr_dpi"
+            )
+            
+            if st.button("حفظ إعدادات استخراج النص", key="save_ocr_settings"):
+                st.success("تم حفظ إعدادات استخراج النص بنجاح!")
+        
+        # إعدادات استخراج البنود
+        with st.expander("إعدادات استخراج البنود", expanded=True):
+            st.markdown("#### إعدادات استخراج البنود")
+            
+            extraction_method = st.selectbox(
+                "طريقة استخراج البنود",
+                ["تحليل الجداول", "تحليل النص", "الذكاء الاصطناعي", "مزيج"],
+                index=3,
+                key="extraction_method"
+            )
+            
+            auto_detect_units = st.checkbox(
+                "اكتشاف الوحدات تلقائياً",
+                value=True,
+                key="auto_detect_units"
+            )
+            
+            normalize_quantities = st.checkbox(
+                "توحيد صيغة الكميات",
+                value=True,
+                key="normalize_quantities"
+            )
+            
+            if st.button("حفظ إعدادات استخراج البنود", key="save_extraction_settings"):
+                st.success("تم حفظ إعدادات استخراج البنود بنجاح!")
+        
+        # إعدادات تحليل الصور
+        with st.expander("إعدادات تحليل الصور", expanded=True):
+            st.markdown("#### إعدادات تحليل الصور")
+            
+            image_analysis_engine = st.selectbox(
+                "محرك تحليل الصور",
+                ["OpenCV", "Google Cloud Vision", "Amazon Rekognition", "Microsoft Azure Computer Vision"],
+                index=0,
+                key="image_analysis_engine"
+            )
+            
+            image_resolution = st.slider(
+                "دقة تحليل الصور",
+                min_value=1,
+                max_value=10,
+                value=5,
+                key="image_resolution"
+            )
+            
+            if st.button("حفظ إعدادات تحليل الصور", key="save_image_analysis_settings"):
+                st.success("تم حفظ إعدادات تحليل الصور بنجاح!")
+        
+        # إعدادات متقدمة
+        with st.expander("إعدادات متقدمة", expanded=False):
+            st.markdown("#### إعدادات متقدمة")
+            
+            temp_files_retention = st.slider(
+                "مدة الاحتفاظ بالملفات المؤقتة (أيام)",
+                min_value=1,
+                max_value=30,
+                value=7,
+                key="temp_files_retention"
+            )
+            
+            max_file_size = st.slider(
+                "الحد الأقصى لحجم الملف (ميجابايت)",
+                min_value=5,
+                max_value=100,
+                value=50,
+                key="max_file_size"
+            )
+            
+            parallel_processing = st.checkbox(
+                "تفعيل المعالجة المتوازية",
+                value=True,
+                key="parallel_processing"
+            )
+            
+            if st.button("حفظ الإعدادات المتقدمة", key="save_advanced_settings"):
+                st.success("تم حفظ الإعدادات المتقدمة بنجاح!")
+    
+    def _save_uploaded_file(self, uploaded_file):
+        """حفظ الملف المرفوع في مجلد مؤقت"""
+        try:
+            file_path = self.temp_dir / uploaded_file.name
+            with open(file_path, "wb") as f:
+                f.write(uploaded_file.getbuffer())
+            return file_path
+        except Exception as e:
+            st.error(f"حدث خطأ أثناء حفظ الملف: {str(e)}")
+            return None
+    
+    def _get_file_info(self, file_path):
+        """الحصول على معلومات الملف"""
+        file_info = {
+            "type": file_path.suffix[1:].upper(),
+            "size": f"{file_path.stat().st_size / (1024 * 1024):.2f} MB"
+        }
+        
+        # محاولة الحصول على عدد الصفحات للملفات المدعومة
+        if file_path.suffix.lower() == ".pdf":
+            # محاكاة عدد الصفحات
+            file_info["pages"] = 10
+        
+        return file_info
+    
+    def _display_analysis_results(self, results):
+        """عرض نتائج التحليل"""
+        
+        if not results:
+            st.info("لا توجد نتائج للعرض.")
+            return
+        
+        # عرض النص المستخرج
+        if "text" in results:
+            with st.expander("النص المستخرج", expanded=False):
+                st.text_area("النص", results["text"], height=200)
+        
+        # عرض الجداول المستخرجة
+        if "tables" in results and results["tables"]:
+            with st.expander("الجداول المستخرجة", expanded=True):
+                for i, table in enumerate(results["tables"]):
+                    st.markdown(f"**جدول {i+1}: {table.get('عنوان', 'بدون عنوان')}**")
+                    
+                    if "بيانات" in table and table["بيانات"]:
+                        # محاولة عرض البيانات كجدول
+                        try:
+                            df = pd.DataFrame(table["بيانات"])
+                            st.dataframe(df, use_container_width=True, hide_index=True)
+                        except Exception:
+                            st.text(str(table["بيانات"]))
+                    else:
+                        st.info("لا توجد بيانات في هذا الجدول.")
+        
+        # عرض البنود المستخرجة
+        if "items" in results and results["items"]:
+            with st.expander("البنود المستخرجة", expanded=True):
+                items_df = pd.DataFrame(results["items"])
+                st.dataframe(items_df, use_container_width=True, hide_index=True)
+                
+                # زر لإرسال البنود إلى وحدة التسعير
+                if st.button("إرسال البنود إلى وحدة التسعير", key="send_extracted_items_button"):
+                    st.session_state.extracted_items = results["items"]
+                    st.success("تم إرسال البنود المستخرجة إلى وحدة التسعير!")
+        
+        # عرض المعلومات الرئيسية
+        if "metadata" in results:
+            with st.expander("المعلومات الرئيسية", expanded=True):
+                metadata = results["metadata"]
+                
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.markdown(f"**عنوان المستند:** {metadata.get('title', 'غير متوفر')}")
+                    st.markdown(f"**المؤلف:** {metadata.get('author', 'غير متوفر')}")
+                
+                with col2:
+                    st.markdown(f"**التاريخ:** {metadata.get('date', 'غير متوفر')}")
+                    st.markdown(f"**عدد الصفحات:** {metadata.get('pages', 'غير متوفر')}")
+        
+        # عرض هيكل المستند
+        if "structure" in results and "sections" in results["structure"]:
+            with st.expander("هيكل المستند", expanded=False):
+                sections = results["structure"]["sections"]
+                
+                for section in sections:
+                    indent = "&nbsp;" * (section["level"] * 4)
+                    st.markdown(f"{indent}• **{section['title']}** (صفحة {section['page']})", unsafe_allow_html=True)

modules/document_comparison/document_comparison_app.py

@@ -0,0 +1,1003 @@
+"""
+وحدة مقارنة المستندات - نظام تحليل المناقصات
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import os
+import sys
+from pathlib import Path
+import difflib
+import re
+import datetime
+
+# إضافة مسار المشروع للنظام
+sys.path.append(str(Path(__file__).parent.parent))
+
+# استيراد محسن واجهة المستخدم
+from styling.enhanced_ui import UIEnhancer
+
+class DocumentComparisonApp:
+    """تطبيق مقارنة المستندات"""
+    
+    def __init__(self):
+        """تهيئة تطبيق مقارنة المستندات"""
+        self.ui = UIEnhancer(page_title="مقارنة المستندات - نظام تحليل المناقصات", page_icon="📄")
+        self.ui.apply_theme_colors()
+        
+        # بيانات المستندات (نموذجية)
+        self.documents_data = [
+            {
+                "id": "DOC001",
+                "name": "كراسة الشروط - مناقصة إنشاء مبنى إداري",
+                "type": "كراسة شروط",
+                "version": "1.0",
+                "date": "2025-01-15",
+                "size": 2.4,
+                "pages": 45,
+                "related_entity": "T-2025-001",
+                "path": "/documents/T-2025-001/specs_v1.pdf"
+            },
+            {
+                "id": "DOC002",
+                "name": "كراسة الشروط - مناقصة إنشاء مبنى إداري",
+                "type": "كراسة شروط",
+                "version": "1.1",
+                "date": "2025-02-10",
+                "size": 2.6,
+                "pages": 48,
+                "related_entity": "T-2025-001",
+                "path": "/documents/T-2025-001/specs_v1.1.pdf"
+            },
+            {
+                "id": "DOC003",
+                "name": "كراسة الشروط - مناقصة إنشاء مبنى إداري",
+                "type": "كراسة شروط",
+                "version": "2.0",
+                "date": "2025-03-05",
+                "size": 2.8,
+                "pages": 52,
+                "related_entity": "T-2025-001",
+                "path": "/documents/T-2025-001/specs_v2.0.pdf"
+            },
+            {
+                "id": "DOC004",
+                "name": "جدول الكميات - مناقصة إنشاء مبنى إداري",
+                "type": "جدول كميات",
+                "version": "1.0",
+                "date": "2025-01-15",
+                "size": 1.2,
+                "pages": 20,
+                "related_entity": "T-2025-001",
+                "path": "/documents/T-2025-001/boq_v1.0.xlsx"
+            },
+            {
+                "id": "DOC005",
+                "name": "جدول الكميات - مناقصة إنشاء مبنى إداري",
+                "type": "جدول كميات",
+                "version": "1.1",
+                "date": "2025-02-20",
+                "size": 1.3,
+                "pages": 22,
+                "related_entity": "T-2025-001",
+                "path": "/documents/T-2025-001/boq_v1.1.xlsx"
+            },
+            {
+                "id": "DOC006",
+                "name": "المخططات - مناقصة إنشاء مبنى إداري",
+                "type": "مخططات",
+                "version": "1.0",
+                "date": "2025-01-15",
+                "size": 15.6,
+                "pages": 30,
+                "related_entity": "T-2025-001",
+                "path": "/documents/T-2025-001/drawings_v1.0.pdf"
+            },
+            {
+                "id": "DOC007",
+                "name": "المخططات - مناقصة إنشاء مبنى إداري",
+                "type": "مخططات",
+                "version": "2.0",
+                "date": "2025-03-10",
+                "size": 18.2,
+                "pages": 35,
+                "related_entity": "T-2025-001",
+                "path": "/documents/T-2025-001/drawings_v2.0.pdf"
+            },
+            {
+                "id": "DOC008",
+                "name": "كراسة الشروط - مناقصة صيانة طرق",
+                "type": "كراسة شروط",
+                "version": "1.0",
+                "date": "2025-02-05",
+                "size": 1.8,
+                "pages": 32,
+                "related_entity": "T-2025-002",
+                "path": "/documents/T-2025-002/specs_v1.0.pdf"
+            },
+            {
+                "id": "DOC009",
+                "name": "كراسة الشروط - مناقصة صيانة طرق",
+                "type": "كراسة شروط",
+                "version": "1.1",
+                "date": "2025-03-15",
+                "size": 1.9,
+                "pages": 34,
+                "related_entity": "T-2025-002",
+                "path": "/documents/T-2025-002/specs_v1.1.pdf"
+            },
+            {
+                "id": "DOC010",
+                "name": "جدول الكميات - مناقصة صيانة طرق",
+                "type": "جدول كميات",
+                "version": "1.0",
+                "date": "2025-02-05",
+                "size": 0.9,
+                "pages": 15,
+                "related_entity": "T-2025-002",
+                "path": "/documents/T-2025-002/boq_v1.0.xlsx"
+            }
+        ]
+        
+        # بيانات نموذجية لمحتوى المستندات (للعرض فقط)
+        self.sample_document_content = {
+            "DOC001": """
+            # كراسة الشروط والمواصفات
+            ## مناقصة إنشاء مبنى إداري
+            
+            ### 1. مقدمة
+            تدعو شركة شبه الجزيرة للمقاولات الشركات المتخصصة للتقدم بعروضها لتنفيذ مشروع إنشاء مبنى إداري في مدينة الرياض.
+            
+            ### 2. نطاق العمل
+            يشمل نطاق العمل تصميم وتنفيذ مبنى إداري مكون من 5 طوابق بمساحة إجمالية 5000 متر مربع، ويشمل ذلك:
+            - أعمال الهيكل الإنشائي
+            - أعمال التشطيبات الداخلية والخارجية
+            - أعمال الكهرباء والميكانيكا
+            - أعمال تنسيق الموقع
+            
+            ### 3. المواصفات الفنية
+            #### 3.1 أعمال الخرسانة
+            - يجب أن تكون الخرسانة المسلحة بقوة لا تقل عن 30 نيوتن/مم²
+            - يجب استخدام حديد تسليح مطابق للمواصفات السعودية
+            
+            #### 3.2 أعمال التشطيبات
+            - يجب استخدام مواد عالية الجودة للتشطيبات الداخلية
+            - يجب أن تكون الواجهات الخارجية مقاومة للعوامل الجوية
+            
+            ### 4. الشروط العامة
+            - مدة التنفيذ: 18 شهراً من تاريخ استلام الموقع
+            - غرامة التأخير: 0.1% من قيمة العقد عن كل يوم تأخير
+            - ضمان الأعمال: 10 سنوات للهيكل الإنشائي، 5 سنوات للأعمال الميكانيكية والكهربائية
+            """,
+            
+            "DOC002": """
+            # كراسة الشروط والمواصفات
+            ## مناقصة إنشاء مبنى إداري
+            
+            ### 1. مقدمة
+            تدعو شركة شبه الجزيرة للمقاولات الشركات المتخصصة للتقدم بعروضها لتنفيذ مشروع إنشاء مبنى إداري في مدينة الرياض.
+            
+            ### 2. نطاق العمل
+            يشمل نطاق العمل تصميم وتنفيذ مبنى إداري مكون من 5 طوابق بمساحة إجمالية 5500 متر مربع، ويشمل ذلك:
+            - أعمال الهيكل الإنشائي
+            - أعمال التشطيبات الداخلية والخارجية
+            - أعمال الكهرباء والميكانيكا
+            - أعمال تنسيق الموقع
+            - أعمال أنظمة الأمن والسلامة
+            
+            ### 3. المواصفات الفنية
+            #### 3.1 أعمال الخرسانة
+            - يجب أن تكون الخرسانة المسلحة بقوة لا تقل عن 35 نيوتن/مم²
+            - يجب استخدام حديد تسليح مطابق للمواصفات السعودية
+            
+            #### 3.2 أعمال التشطيبات
+            - يجب استخدام مواد عالية الجودة للتشطيبات الداخلية
+            - يجب أن تكون الواجهات الخارجية مقاومة للعوامل الجوية
+            - يجب استخدام زجاج عاكس للحرارة للواجهات
+            
+            ### 4. الشروط العامة
+            - مدة التنفيذ: 16 شهراً من تاريخ استلام الموقع
+            - غرامة التأخير: 0.15% من قيمة العقد عن كل يوم تأخير
+            - ضمان الأعمال: 10 سنوات للهيكل الإنشائي، 5 سنوات للأعمال الميكانيكية والكهربائية
+            """,
+            
+            "DOC003": """
+            # كراسة الشروط والمواصفات
+            ## مناقصة إنشاء مبنى إداري
+            
+            ### 1. مقدمة
+            تدعو شركة شبه الجزيرة للمقاولات الشركات المتخصصة للتقدم بعروضها لتنفيذ مشروع إنشاء مبنى إداري في مدينة الرياض وفقاً للمواصفات المعتمدة من الهيئة السعودية للمواصفات والمقاييس.
+            
+            ### 2. نطاق العمل
+            يشمل نطاق العمل تصميم وتنفيذ مبنى إداري مكون من 6 طوابق بمساحة إجمالية 6000 متر مربع، ويشمل ذلك:
+            - أعمال الهيكل الإنشائي
+            - أعمال التشطيبات الداخلية والخارجية
+            - أعمال الكهرباء والميكانيكا
+            - أعمال تنسيق الموقع
+            - أعمال أنظمة الأمن والسلامة
+            - أعمال أنظمة المباني الذكية
+            
+            ### 3. المواصفات الفنية
+            #### 3.1 أعمال الخرسانة
+            - يجب أن تكون الخرسانة المسلحة بقوة لا تقل عن 40 نيوتن/مم²
+            - يجب استخدام حديد تسليح مطابق للمواصفات السعودية
+            - يجب استخدام إضافات للخرسانة لزيادة مقاومتها للعوامل الجوية
+            
+            #### 3.2 أعمال التشطيبات
+            - يجب استخدام مواد عالية الجودة للتشطيبات الداخلية
+            - يجب أن تكون الواجهات الخارجية مقاومة للعوامل الجوية
+            - يجب استخدام زجاج عاكس للحرارة للواجهات
+            - يجب استخدام مواد صديقة للبيئة
+            
+            ### 4. الشروط العامة
+            - مدة التنفيذ: 15 شهراً من تاريخ استلام الموقع
+            - غرامة التأخير: 0.2% من قيمة العقد عن كل يوم تأخير
+            - ضمان الأعمال: 15 سنوات للهيكل الإنشائي، 7 سنوات للأعمال الميكانيكية والكهربائية
+            
+            ### 5. متطلبات الاستدامة
+            - يجب أن يحقق المبنى متطلبات الاستدامة وفقاً لمعايير LEED
+            - يجب توفير أنظمة لترشيد استهلاك الطاقة والمياه
+            """
+        }
+    
+    def run(self):
+        """تشغيل تطبيق مقارنة المستندات"""
+        # إنشاء قائمة العناصر
+        menu_items = [
+            {"name": "لوحة المعلومات", "icon": "house"},
+            {"name": "المناقصات والعقود", "icon": "file-text"},
+            {"name": "تحليل المستندات", "icon": "file-earmark-text"},
+            {"name": "نظام التسعير", "icon": "calculator"},
+            {"name": "حاسبة تكاليف البناء", "icon": "building"},
+            {"name": "الموارد والتكاليف", "icon": "people"},
+            {"name": "تحليل المخاطر", "icon": "exclamation-triangle"},
+            {"name": "إدارة المشاريع", "icon": "kanban"},
+            {"name": "الخرائط والمواقع", "icon": "geo-alt"},
+            {"name": "الجدول الزمني", "icon": "calendar3"},
+            {"name": "الإشعارات", "icon": "bell"},
+            {"name": "مقارنة المستندات", "icon": "files"},
+            {"name": "المساعد الذكي", "icon": "robot"},
+            {"name": "التقارير", "icon": "bar-chart"},
+            {"name": "الإعدادات", "icon": "gear"}
+        ]
+        
+        # إنشاء الشريط الجانبي
+        selected = self.ui.create_sidebar(menu_items)
+        
+        # إنشاء ترويسة الصفحة
+        self.ui.create_header("مقارنة المستندات", "أدوات متقدمة لمقارنة وتحليل المستندات")
+        
+        # إنشاء علامات تبويب للوظائف المختلفة
+        tabs = st.tabs(["مقارنة الإصدارات", "مقارنة المستندات", "تحليل التغييرات", "سجل التغييرات"])
+        
+        # علامة تبويب مقارنة الإصدارات
+        with tabs[0]:
+            self.compare_versions()
+        
+        # علامة تبويب مقارنة المستندات
+        with tabs[1]:
+            self.compare_documents()
+        
+        # علامة تبويب تحليل التغييرات
+        with tabs[2]:
+            self.analyze_changes()
+        
+        # علامة تبويب سجل التغييرات
+        with tabs[3]:
+            self.show_change_history()
+    
+    def compare_versions(self):
+        """مقارنة إصدارات المستندات"""
+        st.markdown("### مقارنة إصدارات المستندات")
+        
+        # اختيار المناقصة
+        tender_options = list(set([doc["related_entity"] for doc in self.documents_data]))
+        selected_tender = st.selectbox(
+            "اختر المناقصة",
+            options=tender_options
+        )
+        
+        # فلترة المستندات حسب المناقصة المختارة
+        filtered_docs = [doc for doc in self.documents_data if doc["related_entity"] == selected_tender]
+        
+        # اختيار نوع المستند
+        doc_types = list(set([doc["type"] for doc in filtered_docs]))
+        selected_type = st.selectbox(
+            "اختر نوع المستند",
+            options=doc_types
+        )
+        
+        # فلترة المستندات حسب النوع المختار
+        type_filtered_docs = [doc for doc in filtered_docs if doc["type"] == selected_type]
+        
+        # ترتيب المستندات حسب الإصدار
+        type_filtered_docs = sorted(type_filtered_docs, key=lambda x: x["version"])
+        
+        if len(type_filtered_docs) < 2:
+            st.warning("يجب توفر إصدارين على الأقل للمقارنة")
+        else:
+            # اختيار الإصدارات للمقارنة
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                version_options = [f"{doc['name']} (الإصدار {doc['version']})" for doc in type_filtered_docs]
+                selected_version1_index = st.selectbox(
+                    "الإصدار الأول",
+                    options=range(len(version_options)),
+                    format_func=lambda x: version_options[x]
+                )
+                selected_doc1 = type_filtered_docs[selected_version1_index]
+            
+            with col2:
+                remaining_indices = [i for i in range(len(type_filtered_docs)) if i != selected_version1_index]
+                selected_version2_index = st.selectbox(
+                    "الإصدار الثاني",
+                    options=remaining_indices,
+                    format_func=lambda x: version_options[x]
+                )
+                selected_doc2 = type_filtered_docs[selected_version2_index]
+            
+            # زر بدء المقارنة
+            if st.button("بدء المقارنة", use_container_width=True):
+                # عرض معلومات المستندات المختارة
+                st.markdown("### معلومات المستندات المختارة")
+                
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.markdown(f"**الإصدار الأول:** {selected_doc1['version']}")
+                    st.markdown(f"**التاريخ:** {selected_doc1['date']}")
+                    st.markdown(f"**عدد الصفحات:** {selected_doc1['pages']}")
+                    st.markdown(f"**الحجم:** {selected_doc1['size']} ميجابايت")
+                
+                with col2:
+                    st.markdown(f"**الإصدار الثاني:** {selected_doc2['version']}")
+                    st.markdown(f"**التاريخ:** {selected_doc2['date']}")
+                    st.markdown(f"**عدد الصفحات:** {selected_doc2['pages']}")
+                    st.markdown(f"**الحجم:** {selected_doc2['size']} ميجابايت")
+                
+                # الحصول على محتوى المستندات (في تطبيق حقيقي، سيتم استرجاع المحتوى من الملفات الفعلية)
+                doc1_content = self.sample_document_content.get(selected_doc1["id"], "محتوى المستند غير متوفر")
+                doc2_content = self.sample_document_content.get(selected_doc2["id"], "محتوى المستند غير متوفر")
+                
+                # إجراء المقارنة
+                self.display_comparison(doc1_content, doc2_content)
+    
+    def display_comparison(self, text1, text2):
+        """عرض نتائج المقارنة بين نصين"""
+        st.markdown("### نتائج المقارنة")
+        
+        # تقسيم النصوص إلى أسطر
+        lines1 = text1.splitlines()
+        lines2 = text2.splitlines()
+        
+        # إجراء المقارنة باستخدام difflib
+        d = difflib.Differ()
+        diff = list(d.compare(lines1, lines2))
+        
+        # عرض ملخص التغييرات
+        added = len([line for line in diff if line.startswith('+ ')])
+        removed = len([line for line in diff if line.startswith('- ')])
+        changed = len([line for line in diff if line.startswith('? ')])
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            self.ui.create_metric_card(
+                "الإضافات",
+                str(added),
+                None,
+                self.ui.COLORS['success']
+            )
+        
+        with col2:
+            self.ui.create_metric_card(
+                "الحذف",
+                str(removed),
+                None,
+                self.ui.COLORS['danger']
+            )
+        
+        with col3:
+            self.ui.create_metric_card(
+                "التغييرات",
+                str(changed // 2),  # تقسيم على 2 لأن كل تغيير يظهر مرتين
+                None,
+                self.ui.COLORS['warning']
+            )
+        
+        # عرض التغييرات بالتفصيل
+        st.markdown("### التغييرات بالتفصيل")
+        
+        # إنشاء عرض HTML للتغييرات
+        html_diff = []
+        for line in diff:
+            if line.startswith('+ '):
+                html_diff.append(f'<div style="background-color: #e6ffe6; padding: 2px 5px; margin: 2px 0; border-left: 3px solid green;">{line[2:]}</div>')
+            elif line.startswith('- '):
+                html_diff.append(f'<div style="background-color: #ffe6e6; padding: 2px 5px; margin: 2px 0; border-left: 3px solid red;">{line[2:]}</div>')
+            elif line.startswith('? '):
+                # تجاهل أسطر التفاصيل
+                continue
+            else:
+                html_diff.append(f'<div style="padding: 2px 5px; margin: 2px 0;">{line[2:]}</div>')
+        
+        # عرض التغييرات
+        st.markdown(''.join(html_diff), unsafe_allow_html=True)
+        
+        # خيارات إضافية
+        st.markdown("### خيارات إضافية")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            if st.button("تصدير التغييرات", use_container_width=True):
+                st.success("تم تصدير التغييرات بنجاح")
+        
+        with col2:
+            if st.button("إنشاء تقرير", use_container_width=True):
+                st.success("تم إنشاء التقرير بنجاح")
+        
+        with col3:
+            if st.button("حفظ المقارنة", use_container_width=True):
+                st.success("تم حفظ المقارنة بنجاح")
+    
+    def compare_documents(self):
+        """مقارنة مستندات مختلفة"""
+        st.markdown("### مقارنة مستندات مختلفة")
+        
+        # اختيار المستند الأول
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            tender1_options = list(set([doc["related_entity"] for doc in self.documents_data]))
+            selected_tender1 = st.selectbox(
+                "اختر المناقصة الأولى",
+                options=tender1_options,
+                key="tender1"
+            )
+            
+            # فلترة المستندات حسب المناقصة المختارة
+            filtered_docs1 = [doc for doc in self.documents_data if doc["related_entity"] == selected_tender1]
+            
+            # اختيار المستند
+            doc_options1 = [f"{doc['name']} (الإصدار {doc['version']})" for doc in filtered_docs1]
+            selected_doc1_index = st.selectbox(
+                "اختر المستند الأول",
+                options=range(len(doc_options1)),
+                format_func=lambda x: doc_options1[x],
+                key="doc1"
+            )
+            selected_doc1 = filtered_docs1[selected_doc1_index]
+        
+        with col2:
+            tender2_options = list(set([doc["related_entity"] for doc in self.documents_data]))
+            selected_tender2 = st.selectbox(
+                "اختر المناقصة الثانية",
+                options=tender2_options,
+                key="tender2"
+            )
+            
+            # فلترة المستندات حسب المناقصة المختارة
+            filtered_docs2 = [doc for doc in self.documents_data if doc["related_entity"] == selected_tender2]
+            
+            # اختيار المستند
+            doc_options2 = [f"{doc['name']} (الإصدار {doc['version']})" for doc in filtered_docs2]
+            selected_doc2_index = st.selectbox(
+                "اختر المستند الثاني",
+                options=range(len(doc_options2)),
+                format_func=lambda x: doc_options2[x],
+                key="doc2"
+            )
+            selected_doc2 = filtered_docs2[selected_doc2_index]
+        
+        # خيارات المقارنة
+        st.markdown("### خيارات المقارنة")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            comparison_type = st.radio(
+                "نوع المقارنة",
+                options=["مقارنة كاملة", "مقارنة الأقسام المتطابقة فقط", "مقارنة الاختلافات فقط"]
+            )
+        
+        with col2:
+            ignore_options = st.multiselect(
+                "تجاهل",
+                options=["المسافات", "علامات الترقيم", "حالة الأحرف", "الأرقام"],
+                default=["المسافات"]
+            )
+        
+        with col3:
+            similarity_threshold = st.slider(
+                "عتبة التشابه",
+                min_value=0.0,
+                max_value=1.0,
+                value=0.7,
+                step=0.05
+            )
+        
+        # زر بدء المقارنة
+        if st.button("بدء المقارنة بين المستندات", use_container_width=True):
+            # عرض معلومات المستندات المختارة
+            st.markdown("### معلومات المستندات المختارة")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.markdown(f"**المستند الأول:** {selected_doc1['name']}")
+                st.markdown(f"**الإصدار:** {selected_doc1['version']}")
+                st.markdown(f"**التاريخ:** {selected_doc1['date']}")
+                st.markdown(f"**المناقصة:** {selected_doc1['related_entity']}")
+            
+            with col2:
+                st.markdown(f"**المستند الثاني:** {selected_doc2['name']}")
+                st.markdown(f"**الإصدار:** {selected_doc2['version']}")
+                st.markdown(f"**التاريخ:** {selected_doc2['date']}")
+                st.markdown(f"**المناقصة:** {selected_doc2['related_entity']}")
+            
+            # الحصول على محتوى المستندات (في تطبيق حقيقي، سيتم استرجاع المحتوى من الملفات الفعلية)
+            doc1_content = self.sample_document_content.get(selected_doc1["id"], "محتوى المستند غير متوفر")
+            doc2_content = self.sample_document_content.get(selected_doc2["id"], "محتوى المستند غير متوفر")
+            
+            # إجراء المقارنة
+            self.display_document_comparison(doc1_content, doc2_content, comparison_type, ignore_options, similarity_threshold)
+    
+    def display_document_comparison(self, text1, text2, comparison_type, ignore_options, similarity_threshold):
+        """عرض نتائج المقارنة بين مستندين"""
+        st.markdown("### نتائج المقارنة بين المستندين")
+        
+        # تقسيم النصوص إلى أقسام (في هذا المثال، نستخدم العناوين كفواصل للأقسام)
+        sections1 = self.split_into_sections(text1)
+        sections2 = self.split_into_sections(text2)
+        
+        # حساب نسبة التشابه الإجمالية
+        similarity = difflib.SequenceMatcher(None, text1, text2).ratio()
+        
+        # عرض نسبة التشابه
+        st.markdown(f"**نسبة التشابه الإجمالية:** {similarity:.2%}")
+        
+        # عرض مقارنة الأقسام
+        st.markdown("### مقارنة الأقسام")
+        
+        # إنشاء جدول لمقارنة الأقسام
+        section_comparisons = []
+        
+        for section1_title, section1_content in sections1.items():
+            best_match = None
+            best_similarity = 0
+            
+            for section2_title, section2_content in sections2.items():
+                # حساب نسبة التشابه بين عناوين الأقسام
+                title_similarity = difflib.SequenceMatcher(None, section1_title, section2_title).ratio()
+                
+                # حساب نسبة التشابه بين محتوى الأقسام
+                content_similarity = difflib.SequenceMatcher(None, section1_content, section2_content).ratio()
+                
+                # حساب متوسط نسبة التشابه
+                avg_similarity = (title_similarity + content_similarity) / 2
+                
+                if avg_similarity > best_similarity:
+                    best_similarity = avg_similarity
+                    best_match = {
+                        "title": section2_title,
+                        "content": section2_content,
+                        "similarity": avg_similarity
+                    }
+            
+            # إضافة المقارنة إلى القائمة
+            if best_match and best_similarity >= similarity_threshold:
+                section_comparisons.append({
+                    "section1_title": section1_title,
+                    "section2_title": best_match["title"],
+                    "similarity": best_similarity
+                })
+            else:
+                section_comparisons.append({
+                    "section1_title": section1_title,
+                    "section2_title": "غير موجود",
+                    "similarity": 0
+                })
+        
+        # إضافة الأقسام الموجودة في المستند الثاني فقط
+        for section2_title, section2_content in sections2.items():
+            if not any(comp["section2_title"] == section2_title for comp in section_comparisons):
+                section_comparisons.append({
+                    "section1_title": "غير موجود",
+                    "section2_title": section2_title,
+                    "similarity": 0
+                })
+        
+        # عرض جدول المقارنة
+        section_df = pd.DataFrame(section_comparisons)
+        section_df = section_df.rename(columns={
+            "section1_title": "القسم في المستند الأول",
+            "section2_title": "القسم في المستند الثاني",
+            "similarity": "نسبة التشابه"
+        })
+        
+        # تنسيق نسبة التشابه
+        section_df["نسبة التشابه"] = section_df["نسبة التشابه"].apply(lambda x: f"{x:.2%}")
+        
+        st.dataframe(
+            section_df,
+            use_container_width=True,
+            hide_index=True
+        )
+        
+        # عرض تفاصيل المقارنة
+        st.markdown("### تفاصيل المقارنة")
+        
+        # اختيار قسم للمقارنة التفصيلية
+        selected_section = st.selectbox(
+            "اختر قسماً للمقارنة التفصيلية",
+            options=[comp["section1_title"] for comp in section_comparisons if comp["section1_title"] != "غير موجود"]
+        )
+        
+        # العثور على القسم المقابل في المستند الثاني
+        matching_comparison = next((comp for comp in section_comparisons if comp["section1_title"] == selected_section), None)
+        
+        if matching_comparison and matching_comparison["section2_title"] != "غير موجود":
+            # الحصول على محتوى القسمين
+            section1_content = sections1[selected_section]
+            section2_content = sections2[matching_comparison["section2_title"]]
+            
+            # عرض المقارنة التفصيلية
+            self.display_comparison(section1_content, section2_content)
+        else:
+            st.warning("القسم المحدد غير موجود في المستند الثاني")
+    
+    def split_into_sections(self, text):
+        """تقسيم النص إلى أقسام باستخدام العناوين"""
+        sections = {}
+        current_section = None
+        current_content = []
+        
+        for line in text.splitlines():
+            # البحث عن العناوين (الأسطر التي تبدأ بـ #)
+            if line.strip().startswith('#'):
+                # حفظ القسم السابق إذا وجد
+                if current_section:
+                    sections[current_section] = '\n'.join(current_content)
+                
+                # بدء قسم جديد
+                current_section = line.strip()
+                current_content = []
+            elif current_section:
+                # إضافة السطر إلى محتوى القسم الحالي
+                current_content.append(line)
+        
+        # حفظ القسم الأخير
+        if current_section:
+            sections[current_section] = '\n'.join(current_content)
+        
+        return sections
+    
+    def analyze_changes(self):
+        """تحليل التغييرات في المستندات"""
+        st.markdown("### تحليل التغييرات في المستندات")
+        
+        # اختيار المناقصة
+        tender_options = list(set([doc["related_entity"] for doc in self.documents_data]))
+        selected_tender = st.selectbox(
+            "اختر المناقصة",
+            options=tender_options,
+            key="analyze_tender"
+        )
+        
+        # فلترة المستندات حسب المناقصة المختارة
+        filtered_docs = [doc for doc in self.documents_data if doc["related_entity"] == selected_tender]
+        
+        # تجميع المستندات حسب النوع
+        doc_types = {}
+        for doc in filtered_docs:
+            if doc["type"] not in doc_types:
+                doc_types[doc["type"]] = []
+            doc_types[doc["type"]].append(doc)
+        
+        # عرض تحليل التغييرات لكل نوع مستند
+        for doc_type, docs in doc_types.items():
+            if len(docs) > 1:
+                with st.expander(f"تحليل التغييرات في {doc_type}"):
+                    # ترتيب المستندات حسب الإصدار
+                    sorted_docs = sorted(docs, key=lambda x: x["version"])
+                    
+                    # عرض معلومات الإصدارات
+                    st.markdown(f"**عدد الإصدارات:** {len(sorted_docs)}")
+                    st.markdown(f"**أول إصدار:** {sorted_docs[0]['version']} ({sorted_docs[0]['date']})")
+                    st.markdown(f"**آخر إصدار:** {sorted_docs[-1]['version']} ({sorted_docs[-1]['date']})")
+                    
+                    # حساب التغييرات بين الإصدارات
+                    changes = []
+                    for i in range(1, len(sorted_docs)):
+                        prev_doc = sorted_docs[i-1]
+                        curr_doc = sorted_docs[i]
+                        
+                        # حساب التغييرات (في تطبيق حقيقي، سيتم تحليل المحتوى الفعلي)
+                        page_diff = curr_doc["pages"] - prev_doc["pages"]
+                        size_diff = curr_doc["size"] - prev_doc["size"]
+                        
+                        changes.append({
+                            "from_version": prev_doc["version"],
+                            "to_version": curr_doc["version"],
+                            "date": curr_doc["date"],
+                            "page_diff": page_diff,
+                            "size_diff": size_diff
+                        })
+                    
+                    # عرض جدول التغييرات
+                    changes_df = pd.DataFrame(changes)
+                    changes_df = changes_df.rename(columns={
+                        "from_version": "من الإصدار",
+                        "to_version": "إلى الإصدار",
+                        "date": "تاريخ التغيير",
+                        "page_diff": "التغيير في عدد الصفحات",
+                        "size_diff": "التغيير في الحجم (ميجابايت)"
+                    })
+                    
+                    st.dataframe(
+                        changes_df,
+                        use_container_width=True,
+                        hide_index=True
+                    )
+                    
+                    # عرض رسم بياني للتغييرات
+                    st.markdown("#### تطور حجم المستند عبر الإصدارات")
+                    
+                    versions = [doc["version"] for doc in sorted_docs]
+                    sizes = [doc["size"] for doc in sorted_docs]
+                    
+                    chart_data = pd.DataFrame({
+                        "الإصدار": versions,
+                        "الحجم (ميجابايت)": sizes
+                    })
+                    
+                    st.line_chart(chart_data.set_index("الإصدار"))
+                    
+                    # عرض رسم بياني لعدد الصفحات
+                    st.markdown("#### تطور عدد الصفحات عبر الإصدارات")
+                    
+                    pages = [doc["pages"] for doc in sorted_docs]
+                    
+                    chart_data = pd.DataFrame({
+                        "الإصدار": versions,
+                        "عدد الصفحات": pages
+                    })
+                    
+                    st.line_chart(chart_data.set_index("الإصدار"))
+        
+        # تحليل التغييرات الشاملة
+        st.markdown("### تحليل التغييرات الشاملة")
+        
+        # حساب إجمالي التغييرات (في تطبيق حقيقي، سيتم تحليل المحتوى الفعلي)
+        total_docs = len(filtered_docs)
+        total_versions = sum(len(docs) for docs in doc_types.values())
+        avg_versions = total_versions / len(doc_types) if doc_types else 0
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            self.ui.create_metric_card(
+                "إجمالي المستندات",
+                str(total_docs),
+                None,
+                self.ui.COLORS['primary']
+            )
+        
+        with col2:
+            self.ui.create_metric_card(
+                "إجمالي الإصدارات",
+                str(total_versions),
+                None,
+                self.ui.COLORS['secondary']
+            )
+        
+        with col3:
+            self.ui.create_metric_card(
+                "متوسط الإصدارات لكل نوع",
+                f"{avg_versions:.1f}",
+                None,
+                self.ui.COLORS['accent']
+            )
+        
+        # عرض توزيع التغييرات حسب النوع
+        st.markdown("#### توزيع الإصدارات حسب نوع المستند")
+        
+        type_counts = {doc_type: len(docs) for doc_type, docs in doc_types.items()}
+        
+        chart_data = pd.DataFrame({
+            "نوع المستند": list(type_counts.keys()),
+            "عدد الإصدارات": list(type_counts.values())
+        })
+        
+        st.bar_chart(chart_data.set_index("نوع المستند"))
+    
+    def show_change_history(self):
+        """عرض سجل التغييرات"""
+        st.markdown("### سجل التغييرات")
+        
+        # إنشاء بيانات نموذجية لسجل التغييرات
+        change_history = [
+            {
+                "id": "CH001",
+                "document_id": "DOC001",
+                "document_name": "كراسة الشروط - مناقصة إنشاء مبنى إداري",
+                "from_version": "1.0",
+                "to_version": "1.1",
+                "change_date": "2025-02-10",
+                "change_type": "تحديث",
+                "changed_by": "أحمد محمد",
+                "description": "تحديث المواصفات الفنية وشروط التنفيذ",
+                "sections_changed": ["��طاق العمل", "المواصفات الفنية", "الشروط العامة"]
+            },
+            {
+                "id": "CH002",
+                "document_id": "DOC002",
+                "document_name": "كراسة الشروط - مناقصة إنشاء مبنى إداري",
+                "from_version": "1.1",
+                "to_version": "2.0",
+                "change_date": "2025-03-05",
+                "change_type": "تحديث رئيسي",
+                "changed_by": "سارة عبدالله",
+                "description": "إضافة متطلبات الاستدامة وتحديث المواصفات الفنية",
+                "sections_changed": ["المواصفات الفنية", "الشروط العامة", "متطلبات الاستدامة"]
+            },
+            {
+                "id": "CH003",
+                "document_id": "DOC004",
+                "document_name": "جدول الكميات - مناقصة إنشاء مبنى إداري",
+                "from_version": "1.0",
+                "to_version": "1.1",
+                "change_date": "2025-02-20",
+                "change_type": "تحديث",
+                "changed_by": "خالد عمر",
+                "description": "تحديث الكميات وإضافة بنود جديدة",
+                "sections_changed": ["أعمال الهيكل الإنشائي", "أعمال التشطيبات", "أعمال الكهرباء"]
+            },
+            {
+                "id": "CH004",
+                "document_id": "DOC006",
+                "document_name": "المخططات - مناقصة إنشاء مبنى إداري",
+                "from_version": "1.0",
+                "to_version": "2.0",
+                "change_date": "2025-03-10",
+                "change_type": "تحديث رئيسي",
+                "changed_by": "محمد علي",
+                "description": "تحديث المخططات المعمارية والإنشائية",
+                "sections_changed": ["المخططات المعمارية", "المخططات الإنشائية", "مخططات الكهرباء"]
+            },
+            {
+                "id": "CH005",
+                "document_id": "DOC008",
+                "document_name": "كراسة الشروط - مناقصة صيانة طرق",
+                "from_version": "1.0",
+                "to_version": "1.1",
+                "change_date": "2025-03-15",
+                "change_type": "تحديث",
+                "changed_by": "فاطمة أحمد",
+                "description": "تحديث المواصفات الفنية وشروط التنفيذ",
+                "sections_changed": ["نطاق العمل", "المواصفات الفنية", "الشروط العامة"]
+            }
+        ]
+        
+        # إنشاء فلاتر للسجل
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            document_filter = st.selectbox(
+                "المستند",
+                options=["الكل"] + list(set([ch["document_name"] for ch in change_history]))
+            )
+        
+        with col2:
+            change_type_filter = st.selectbox(
+                "نوع التغيير",
+                options=["الكل"] + list(set([ch["change_type"] for ch in change_history]))
+            )
+        
+        with col3:
+            date_range = st.date_input(
+                "نطاق التاريخ",
+                value=(
+                    datetime.datetime.strptime("2025-01-01", "%Y-%m-%d").date(),
+                    datetime.datetime.strptime("2025-12-31", "%Y-%m-%d").date()
+                )
+            )
+        
+        # تطبيق الفلاتر
+        filtered_history = change_history
+        
+        if document_filter != "الكل":
+            filtered_history = [ch for ch in filtered_history if ch["document_name"] == document_filter]
+        
+        if change_type_filter != "الكل":
+            filtered_history = [ch for ch in filtered_history if ch["change_type"] == change_type_filter]
+        
+        if len(date_range) == 2:
+            start_date, end_date = date_range
+            filtered_history = [
+                ch for ch in filtered_history 
+                if start_date <= datetime.datetime.strptime(ch["change_date"], "%Y-%m-%d").date() <= end_date
+            ]
+        
+        # عرض سجل التغييرات
+        if not filtered_history:
+            st.info("لا توجد تغييرات تطابق الفلاتر المحددة")
+        else:
+            # تحويل البيانات إلى DataFrame
+            history_df = pd.DataFrame(filtered_history)
+            
+            # إعادة ترتيب الأعمدة وتغيير أسمائها
+            display_df = history_df[[
+                "id", "document_name", "from_version", "to_version", "change_date", "change_type", "changed_by", "description"
+            ]].rename(columns={
+                "id": "الرقم",
+                "document_name": "اسم المستند",
+                "from_version": "من الإصدار",
+                "to_version": "إلى الإصدار",
+                "change_date": "تاريخ التغيير",
+                "change_type": "نوع التغيير",
+                "changed_by": "بواسطة",
+                "description": "الوصف"
+            })
+            
+            # عرض الجدول
+            st.dataframe(
+                display_df,
+                use_container_width=True,
+                hide_index=True
+            )
+            
+            # عرض تفاصيل التغيير المحدد
+            st.markdown("### تفاصيل التغيير")
+            
+            selected_change_id = st.selectbox(
+                "اختر تغييراً لعرض التفاصيل",
+                options=[ch["id"] for ch in filtered_history],
+                format_func=lambda x: next((f"{ch['id']} - {ch['document_name']} ({ch['from_version']} إلى {ch['to_version']})" for ch in filtered_history if ch["id"] == x), "")
+            )
+            
+            # العثور على التغيير المحدد
+            selected_change = next((ch for ch in filtered_history if ch["id"] == selected_change_id), None)
+            
+            if selected_change:
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.markdown(f"**المستند:** {selected_change['document_name']}")
+                    st.markdown(f"**من الإصدار:** {selected_change['from_version']}")
+                    st.markdown(f"**إلى الإصدار:** {selected_change['to_version']}")
+                    st.markdown(f"**تاريخ التغيير:** {selected_change['change_date']}")
+                
+                with col2:
+                    st.markdown(f"**نوع التغيير:** {selected_change['change_type']}")
+                    st.markdown(f"**بواسطة:** {selected_change['changed_by']}")
+                    st.markdown(f"**الوصف:** {selected_change['description']}")
+                
+                # عرض الأقسام التي تم تغييرها
+                st.markdown("#### الأقسام التي تم تغييرها")
+                
+                for section in selected_change["sections_changed"]:
+                    st.markdown(f"- {section}")
+                
+                # أزرار الإجراءات
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    if st.button("عرض التغييرات بالتفصيل", use_container_width=True):
+                        st.success("تم فتح التغييرات بالتفصيل")
+                
+                with col2:
+                    if st.button("إنشاء تقرير", use_container_width=True):
+                        st.success("تم إنشاء التقرير بنجاح")
+                
+                with col3:
+                    if st.button("تصدير التغييرات", use_container_width=True):
+                        st.success("تم تصدير التغييرات بنجاح")
+
+# تشغيل التطبيق
+if __name__ == "__main__":
+    doc_comparison_app = DocumentComparisonApp()
+    doc_comparison_app.run()

modules/maps/maps_app.py

@@ -0,0 +1,456 @@
+"""
+وحدة الخرائط والمواقع - نظام تحليل المناقصات
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import folium
+from streamlit_folium import folium_static
+import json
+import os
+import sys
+from pathlib import Path
+
+# إضافة مسار المشروع للنظام
+sys.path.append(str(Path(__file__).parent.parent))
+
+# استيراد محسن واجهة المستخدم
+from styling.enhanced_ui import UIEnhancer
+
+class MapsApp:
+    """تطبيق الخرائط والمواقع"""
+    
+    def __init__(self):
+        """تهيئة تطبيق الخرائط والمواقع"""
+        self.ui = UIEnhancer(page_title="الخرائط والمواقع - نظام تحليل المناقصات", page_icon="🗺️")
+        self.ui.apply_theme_colors()
+        
+        # بيانات المشاريع (نموذجية)
+        self.projects_data = [
+            {
+                "id": "P001",
+                "name": "إنشاء مبنى إداري - الرياض",
+                "location": "الرياض",
+                "coordinates": [24.7136, 46.6753],
+                "status": "جاري التنفيذ",
+                "budget": 15000000,
+                "completion": 45,
+                "client": "وزارة الإسكان",
+                "start_date": "2024-10-15",
+                "end_date": "2025-12-30"
+            },
+            {
+                "id": "P002",
+                "name": "تطوير طريق الملك فهد - جدة",
+                "location": "جدة",
+                "coordinates": [21.5433, 39.1728],
+                "status": "قيد الدراسة",
+                "budget": 8500000,
+                "completion": 0,
+                "client": "أمانة جدة",
+                "start_date": "2025-05-01",
+                "end_date": "2026-02-28"
+            },
+            {
+                "id": "P003",
+                "name": "إنشاء مجمع سكني - الدمام",
+                "location": "الدمام",
+                "coordinates": [26.4207, 50.0888],
+                "status": "مكتمل",
+                "budget": 22000000,
+                "completion": 100,
+                "client": "شركة الإسكان للتطوير",
+                "start_date": "2023-08-10",
+                "end_date": "2025-01-15"
+            },
+            {
+                "id": "P004",
+                "name": "بناء مدرسة - أبها",
+                "location": "أبها",
+                "coordinates": [18.2164, 42.5053],
+                "status": "جاري التنفيذ",
+                "budget": 5200000,
+                "completion": 75,
+                "client": "وزارة التعليم",
+                "start_date": "2024-06-20",
+                "end_date": "2025-07-30"
+            },
+            {
+                "id": "P005",
+                "name": "تطوير شبكة مياه - المدينة المنورة",
+                "location": "المدينة المنورة",
+                "coordinates": [24.5247, 39.5692],
+                "status": "جاري التنفيذ",
+                "budget": 12800000,
+                "completion": 30,
+                "client": "شركة المياه الوطنية",
+                "start_date": "2024-11-05",
+                "end_date": "2026-03-15"
+            }
+        ]
+    
+    def run(self):
+        """تشغيل تطبيق الخرائط والمواقع"""
+        # إنشاء قائمة العناصر
+        menu_items = [
+            {"name": "لوحة المعلومات", "icon": "house"},
+            {"name": "المناقصات والعقود", "icon": "file-text"},
+            {"name": "تحليل المستندات", "icon": "file-earmark-text"},
+            {"name": "نظام التسعير", "icon": "calculator"},
+            {"name": "حاسبة تكاليف البناء", "icon": "building"},
+            {"name": "الموارد والتكاليف", "icon": "people"},
+            {"name": "تحليل المخاطر", "icon": "exclamation-triangle"},
+            {"name": "إدارة المشاريع", "icon": "kanban"},
+            {"name": "الخرائط والمواقع", "icon": "geo-alt"},
+            {"name": "الجدول الزمني", "icon": "calendar3"},
+            {"name": "الإشعارات", "icon": "bell"},
+            {"name": "مقارنة المستندات", "icon": "files"},
+            {"name": "المساعد الذكي", "icon": "robot"},
+            {"name": "التقارير", "icon": "bar-chart"},
+            {"name": "الإعدادات", "icon": "gear"}
+        ]
+        
+        # إنشاء الشريط الجانبي
+        selected = self.ui.create_sidebar(menu_items)
+        
+        # إنشاء ترويسة الصفحة
+        self.ui.create_header("الخرائط والمواقع", "عرض وإدارة مواقع المشاريع")
+        
+        # إنشاء علامات تبويب للوظائ�� المختلفة
+        tabs = st.tabs(["خريطة المشاريع", "تفاصيل المواقع", "إضافة موقع جديد", "تحليل المناطق"])
+        
+        # علامة تبويب خريطة المشاريع
+        with tabs[0]:
+            self.show_projects_map()
+        
+        # علامة تبويب تفاصيل المواقع
+        with tabs[1]:
+            self.show_location_details()
+        
+        # علامة تبويب إضافة موقع جديد
+        with tabs[2]:
+            self.add_new_location()
+        
+        # علامة تبويب تحليل المناطق
+        with tabs[3]:
+            self.analyze_regions()
+    
+    def show_projects_map(self):
+        """عرض خريطة المشاريع"""
+        # إنشاء فلاتر للخريطة
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            status_filter = st.multiselect(
+                "حالة المشروع",
+                options=["الكل", "جاري التنفيذ", "قيد الدراسة", "مكتمل"],
+                default=["الكل"]
+            )
+        
+        with col2:
+            location_filter = st.multiselect(
+                "الموقع",
+                options=["الكل"] + list(set([p["location"] for p in self.projects_data])),
+                default=["الكل"]
+            )
+        
+        with col3:
+            budget_range = st.slider(
+                "نطاق الميزانية (مليون ريال)",
+                0.0, 25.0, (0.0, 25.0),
+                step=0.5
+            )
+        
+        # تطبيق الفلاتر
+        filtered_projects = self.projects_data
+        
+        if "الكل" not in status_filter and status_filter:
+            filtered_projects = [p for p in filtered_projects if p["status"] in status_filter]
+        
+        if "الكل" not in location_filter and location_filter:
+            filtered_projects = [p for p in filtered_projects if p["location"] in location_filter]
+        
+        filtered_projects = [p for p in filtered_projects if budget_range[0] * 1000000 <= p["budget"] <= budget_range[1] * 1000000]
+        
+        # إنشاء الخريطة
+        st.markdown("### خريطة المشاريع")
+        
+        # تحديد مركز الخريطة (وسط المملكة العربية السعودية تقريباً)
+        center = [24.0, 45.0]
+        
+        # إنشاء خريطة folium
+        m = folium.Map(location=center, zoom_start=5, tiles="OpenStreetMap")
+        
+        # إضافة المشاريع إلى الخريطة
+        for project in filtered_projects:
+            # تحديد لون العلامة بناءً على حالة المشروع
+            if project["status"] == "جاري التنفيذ":
+                color = "blue"
+            elif project["status"] == "قيد الدراسة":
+                color = "orange"
+            elif project["status"] == "مكتمل":
+                color = "green"
+            else:
+                color = "gray"
+            
+            # إنشاء نص النافذة المنبثقة
+            popup_text = f"""
+            <div dir="rtl" style="text-align: right; width: 200px;">
+                <h4>{project['name']}</h4>
+                <p><strong>الحالة:</strong> {project['status']}</p>
+                <p><strong>الميزانية:</strong> {project['budget']:,} ريال</p>
+                <p><strong>نسبة الإنجاز:</strong> {project['completion']}%</p>
+                <p><strong>العميل:</strong> {project['client']}</p>
+                <p><strong>تاريخ البدء:</strong> {project['start_date']}</p>
+                <p><strong>تاريخ الانتهاء:</strong> {project['end_date']}</p>
+                <a href="#" onclick="alert('تم فتح تفاصيل المشروع');">عرض التفاصيل</a>
+            </div>
+            """
+            
+            # إضافة علامة للمشروع
+            folium.Marker(
+                location=project["coordinates"],
+                popup=folium.Popup(popup_text, max_width=300),
+                tooltip=project["name"],
+                icon=folium.Icon(color=color, icon="info-sign")
+            ).add_to(m)
+        
+        # عرض الخريطة
+        folium_static(m, width=1000, height=500)
+        
+        # عرض إحصائيات المشاريع
+        st.markdown("### إحصائيات المشاريع")
+        
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            self.ui.create_metric_card(
+                "إجمالي المشاريع",
+                str(len(filtered_projects)),
+                None,
+                self.ui.COLORS['primary']
+            )
+        
+        with col2:
+            projects_in_progress = len([p for p in filtered_projects if p["status"] == "جاري التنفيذ"])
+            self.ui.create_metric_card(
+                "مشاريع جاري��",
+                str(projects_in_progress),
+                None,
+                self.ui.COLORS['secondary']
+            )
+        
+        with col3:
+            total_budget = sum([p["budget"] for p in filtered_projects])
+            self.ui.create_metric_card(
+                "إجمالي الميزانية",
+                f"{total_budget/1000000:.1f} مليون ريال",
+                None,
+                self.ui.COLORS['accent']
+            )
+        
+        with col4:
+            avg_completion = np.mean([p["completion"] for p in filtered_projects])
+            self.ui.create_metric_card(
+                "متوسط نسبة الإنجاز",
+                f"{avg_completion:.1f}%",
+                None,
+                self.ui.COLORS['success']
+            )
+    
+    def show_location_details(self):
+        """عرض تفاصيل المواقع"""
+        st.markdown("### تفاصيل مواقع المشاريع")
+        
+        # إنشاء جدول بيانات المشاريع
+        projects_df = pd.DataFrame(self.projects_data)
+        projects_df = projects_df.rename(columns={
+            "id": "رقم المشروع",
+            "name": "اسم المشروع",
+            "location": "الموقع",
+            "status": "الحالة",
+            "budget": "الميزانية (ريال)",
+            "completion": "نسبة الإنجاز (%)",
+            "client": "العميل",
+            "start_date": "تاريخ البدء",
+            "end_date": "تاريخ الانتهاء"
+        })
+        
+        # حذف عمود الإحداثيات من العرض
+        projects_df = projects_df.drop(columns=["coordinates"])
+        
+        # عرض الجدول
+        st.dataframe(
+            projects_df,
+            use_container_width=True,
+            hide_index=True
+        )
+        
+        # إضافة خيار تصدير البيانات
+        col1, col2 = st.columns([1, 5])
+        with col1:
+            self.ui.create_button("تصدير البيانات", "primary")
+        
+        # عرض تفاصيل مشروع محدد
+        st.markdown("### تفاصيل مشروع محدد")
+        
+        selected_project = st.selectbox(
+            "اختر مشروعاً لعرض التفاصيل",
+            options=[p["name"] for p in self.projects_data]
+        )
+        
+        # العثور على المشروع المحدد
+        project = next((p for p in self.projects_data if p["name"] == selected_project), None)
+        
+        if project:
+            col1, col2 = st.columns([2, 1])
+            
+            with col1:
+                # عرض تفاصيل المشروع
+                st.markdown(f"#### {project['name']}")
+                st.markdown(f"**الموقع:** {project['location']}")
+                st.markdown(f"**الحالة:** {project['status']}")
+                st.markdown(f"**الميزانية:** {project['budget']:,} ريال")
+                st.markdown(f"**نسبة الإنجاز:** {project['completion']}%")
+                st.markdown(f"**العميل:** {project['client']}")
+                st.markdown(f"**تاريخ البدء:** {project['start_date']}")
+                st.markdown(f"**تاريخ الانتهاء:** {project['end_date']}")
+                
+                # أزرار الإجراءات
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    self.ui.create_button("تعديل البيانات", "primary")
+                with col2:
+                    self.ui.create_button("عرض المستندات", "secondary")
+                with col3:
+                    self.ui.create_button("تقرير الموقع", "accent")
+            
+            with col2:
+                # عرض خريطة مصغرة للمشروع
+                m = folium.Map(location=project["coordinates"], zoom_start=12)
+                folium.Marker(
+                    location=project["coordinates"],
+                    tooltip=project["name"],
+                    icon=folium.Icon(color="red", icon="info-sign")
+                ).add_to(m)
+                folium_static(m, width=300, height=300)
+    
+    def add_new_location(self):
+        """إضافة موقع جديد"""
+        st.markdown("### إضافة موقع مشروع جديد")
+        
+        # نموذج إضافة موقع جديد
+        with st.form("new_location_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                project_id = st.text_input("رقم المشروع", value="P00" + str(len(self.projects_data) + 1))
+                project_name = st.text_input("اسم المشروع")
+                location = st.text_input("الموقع")
+                status = st.selectbox(
+                    "الحالة",
+                    options=["جاري التنفيذ", "قيد الدراسة", "مكتمل"]
+                )
+                budget = st.number_input("الميزانية (ريال)", min_value=0, step=100000)
+            
+            with col2:
+                completion = st.slider("نسبة الإنجاز (%)", 0, 100, 0)
+                client = st.text_input("العميل")
+                start_date = st.date_input("تاريخ البدء")
+                end_date = st.date_input("تاريخ الانتهاء")
+            
+            st.markdown("### تحديد الموقع على الخريطة")
+            st.markdown("انقر على الخريطة لتحديد موقع المشروع أو أدخل الإحداثيات يدوياً")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                latitude = st.number_input("خط العرض", value=24.0, format="%.4f")
+            
+            with col2:
+                longitude = st.number_input("خط الطول", value=45.0, format="%.4f")
+            
+            # عرض الخريطة لتحديد الموقع
+            m = folium.Map(location=[latitude, longitude], zoom_start=5)
+            folium.Marker(
+                location=[latitude, longitude],
+                tooltip="موقع المشروع الجديد",
+                icon=folium.Icon(color="red", icon="info-sign")
+            ).add_to(m)
+            folium_static(m, width=700, height=300)
+            
+            # زر الإرسال
+            submit_button = st.form_submit_button("إضافة المشروع")
+            
+            if submit_button:
+                # إضافة المشروع الجديد (في تطبيق حقيقي، سيتم حفظ البيانات في قاعدة البيانات)
+                st.success("تم إضافة المشروع بنجاح!")
+                
+                # إعادة تعيين النموذج
+                st.experimental_rerun()
+    
+    def analyze_regions(self):
+        """تحليل المناطق"""
+        st.markdown("### تحليل المناطق")
+        
+        # إنشاء بيانات المناطق (نموذجية)
+        regions_data = {
+            "المنطقة": ["الرياض", "مكة المكرمة", "المدينة المنورة", "القصيم", "المنطقة الشرقية", "عسير", "تبوك", "حائل", "الحدود الشمالية", "جازان", "نجران", "الباحة", "الجوف"],
+            "عدد المشاريع": [15, 12, 8, 5, 18, 7, 4, 3, 2, 6, 3, 2, 3],
+            "إجمالي الميزانية (مليون ريال)": [120, 95, 45, 30, 150, 40, 25, 18, 12, 35, 20, 15, 22],
+            "متوسط مدة المشروع (شهر)": [18, 16, 14, 12, 20, 15, 12, 10, 9, 14, 12, 10, 11]
+        }
+        
+        regions_df = pd.DataFrame(regions_data)
+        
+        # عرض خريطة حرارية للمناطق
+        st.markdown("#### توزيع المشاريع حسب المناطق")
+        
+        # في تطبيق حقيقي، يمكن استخدام خريطة حرارية حقيقية للمملكة
+        st.image("https://via.placeholder.com/800x400?text=خريطة+حرارية+للمشاريع+حسب+المناطق", use_column_width=True)
+        
+        # عرض إحصائيات المناطق
+        st.markdown("#### إحصائيات المناطق")
+        
+        # عرض الجدول
+        st.dataframe(
+            regions_df,
+            use_container_width=True,
+            hide_index=True
+        )
+        
+        # عرض رسوم بيانية للمقارنة
+        st.markdown("#### مقارنة المناطق")
+        
+        chart_type = st.radio(
+            "نوع الرسم البياني",
+            options=["عدد المشاريع", "إجمالي الميزانية", "متوسط مدة المشروع"],
+            horizontal=True
+        )
+        
+        if chart_type == "عدد المشاريع":
+            chart_data = regions_df[["المنطقة", "عدد المشاريع"]].sort_values(by="عدد المشاريع", ascending=False)
+            st.bar_chart(chart_data.set_index("المنطقة"))
+        elif chart_type == "إجمالي الميزانية":
+            chart_data = regions_df[["المنطقة", "إجمالي الميزانية (مليون ريال)"]].sort_values(by="إجمالي الميزانية (مليون ريال)", ascending=False)
+            st.bar_chart(chart_data.set_index("المنطقة"))
+        else:
+            chart_data = regions_df[["المنطقة", "متوسط مدة المشروع (شهر)"]].sort_values(by="متوسط مدة المشروع (شهر)", ascending=False)
+            st.bar_chart(chart_data.set_index("المنطقة"))
+        
+        # تحليل الكثافة
+        st.markdown("#### تحليل كثافة المشاريع")
+        st.markdown("""
+        يوضح هذا التحليل توزيع المشاريع حسب المناطق الجغرافية، مما يساعد في:
+        - تحديد المناطق ذات النشاط العالي
+        - تحديد فرص النمو في المن��طق الأقل نشاطاً
+        - تخطيط الموارد بناءً على التوزيع الجغرافي
+        """)
+        
+        # في تطبيق حقيقي، يمكن إضافة تحليلات أكثر تفصيلاً
+
+# تشغيل التطبيق
+if __name__ == "__main__":
+    maps_app = MapsApp()
+    maps_app.run()

modules/notifications/notifications_app.py

@@ -0,0 +1,707 @@
+"""
+وحدة الإشعارات الذكية - نظام تحليل المناقصات
+"""
+
+import streamlit as st
+import pandas as pd
+import datetime
+import json
+import os
+import sys
+from pathlib import Path
+
+# إضافة مسار المشروع للنظام
+sys.path.append(str(Path(__file__).parent.parent))
+
+# استيراد محسن واجهة المستخدم
+from styling.enhanced_ui import UIEnhancer
+
+class NotificationsApp:
+    """تطبيق الإشعارات الذكية"""
+    
+    def __init__(self):
+        """تهيئة تطبيق الإشعارات الذكية"""
+        self.ui = UIEnhancer(page_title="الإشعارات الذكية - نظام تحليل المناقصات", page_icon="🔔")
+        
+        # تهيئة متغير السمة في حالة الجلسة إذا لم يكن موجوداً
+        if 'theme' not in st.session_state:
+            st.session_state.theme = 'light'
+            
+        self.ui.apply_theme_colors()
+        
+        # بيانات الإشعارات (نموذجية)
+        self.notifications_data = [
+            {
+                "id": "N001",
+                "title": "موعد تسليم مناقصة",
+                "message": "موعد تسليم مناقصة T-2025-001 (إنشاء مبنى إداري) بعد 5 أيام",
+                "type": "deadline",
+                "priority": "high",
+                "related_entity": "T-2025-001",
+                "created_at": "2025-03-25T10:30:00",
+                "is_read": False
+            },
+            {
+                "id": "N002",
+                "title": "ترسية مناقصة",
+                "message": "تم ترسية مناقصة T-2025-003 (توريد معدات) بنجاح",
+                "type": "award",
+                "priority": "medium",
+                "related_entity": "T-2025-003",
+                "created_at": "2025-03-28T14:15:00",
+                "is_read": True
+            },
+            {
+                "id": "N003",
+                "title": "تحديث مستندات",
+                "message": "تم تحديث مستندات مناقصة T-2025-002 (صيانة طرق)",
+                "type": "document",
+                "priority": "medium",
+                "related_entity": "T-2025-002",
+                "created_at": "2025-03-29T09:45:00",
+                "is_read": False
+            },
+            {
+                "id": "N004",
+                "title": "تغيير في المواصفات",
+                "message": "تم تغيير المواصفات الفنية لمناقصة T-2025-001 (إنشاء مبنى إداري)",
+                "type": "change",
+                "priority": "high",
+                "related_entity": "T-2025-001",
+                "created_at": "2025-03-27T11:20:00",
+                "is_read": False
+            },
+            {
+                "id": "N005",
+                "title": "تأخير في المشروع",
+                "message": "تأخير في تنفيذ مشروع P002 (تطوير طريق الملك فهد - جدة)",
+                "type": "delay",
+                "priority": "high",
+                "related_entity": "P002",
+                "created_at": "2025-03-26T16:10:00",
+                "is_read": True
+            },
+            {
+                "id": "N006",
+                "title": "اكتمال مرحلة",
+                "message": "اكتمال مرحلة الأساسات في مشروع P001 (إنشاء مبنى إداري - الرياض)",
+                "type": "milestone",
+                "priority": "low",
+                "related_entity": "P001",
+                "created_at": "2025-03-24T13:30:00",
+                "is_read": True
+            },
+            {
+                "id": "N007",
+                "title": "طلب معلومات إضافية",
+                "message": "طلب معلومات إضافية لمناقصة T-2025-004 (تجهيز مختبرات)",
+                "type": "request",
+                "priority": "medium",
+                "related_entity": "T-2025-004",
+                "created_at": "2025-03-30T08:15:00",
+                "is_read": False
+            },
+            {
+                "id": "N008",
+                "title": "تحديث أسعار المواد",
+                "message": "تم تحديث أسعار مواد البناء في قاعدة البيانات",
+                "type": "update",
+                "priority": "low",
+                "related_entity": "DB-MATERIALS",
+                "created_at": "2025-03-29T15:40:00",
+                "is_read": False
+            },
+            {
+                "id": "N009",
+                "title": "اجتماع فريق العمل",
+                "message": "اجتماع فريق العمل لمناقشة مناقصة T-2025-001 غداً الساعة 10:00 صباحاً",
+                "type": "meeting",
+                "priority": "medium",
+                "related_entity": "T-2025-001",
+                "created_at": "2025-03-28T16:20:00",
+                "is_read": True
+            },
+            {
+                "id": "N010",
+                "title": "تغيير في الميزانية",
+                "message": "تم تغيير الميزانية المخصصة لمشروع P004 (بناء مدرسة - أبها)",
+                "type": "budget",
+                "priority": "high",
+                "related_entity": "P004",
+                "created_at": "2025-03-25T14:50:00",
+                "is_read": False
+            }
+        ]
+        
+        # إعدادات الإشعارات (نموذجية)
+        self.notification_settings = {
+            "deadline": True,
+            "award": True,
+            "document": True,
+            "change": True,
+            "delay": True,
+            "milestone": True,
+            "request": True,
+            "update": True,
+            "meeting": True,
+            "budget": True,
+            "email_notifications": True,
+            "sms_notifications": False,
+            "push_notifications": True,
+            "notification_frequency": "realtime"
+        }
+    
+    def run(self):
+        """تشغيل تطبيق الإشعارات الذكية"""
+        # إضافة زر تبديل السمة في أعلى الصفحة
+        col1, col2, col3 = st.columns([1, 8, 1])
+        with col3:
+            if st.button("🌓 تبديل السمة"):
+                # تبديل السمة
+                if st.session_state.theme == "light":
+                    st.session_state.theme = "dark"
+                else:
+                    st.session_state.theme = "light"
+                
+                # تطبيق السمة الجديدة
+                self.ui.theme_mode = st.session_state.theme
+                self.ui.apply_theme_colors()
+                st.rerun()
+        
+        # إنشاء ترويسة الصفحة
+        self.ui.create_header("الإشعارات الذكية", "إدارة ومتابعة الإشعارات والتنبيهات")
+        
+        # إنشاء علامات تبويب للوظائف المختلفة
+        tabs = st.tabs(["الإشعارات الحالية", "إعدادات الإشعارات", "إنشاء إشعار", "سجل الإشعارات"])
+        
+        # علامة تبويب الإشعارات الحالية
+        with tabs[0]:
+            self.show_current_notifications()
+        
+        # علامة تبويب إعدادات الإشعارات
+        with tabs[1]:
+            self.show_notification_settings()
+        
+        # علامة تبويب إنشاء إشعار
+        with tabs[2]:
+            self.create_notification()
+        
+        # علامة تبويب سجل الإشعارات
+        with tabs[3]:
+            self.show_notification_history()
+    
+    def show_current_notifications(self):
+        """عرض الإشعارات الحالية"""
+        st.markdown("### الإشعارات الحالية")
+        
+        # إنشاء فلاتر للإشعارات
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            type_filter = st.multiselect(
+                "نوع الإشعار",
+                options=["الكل", "موعد نهائي", "ترسية", "مستند", "تغيير", "تأخير", "مرحلة", "طلب", "تحديث", "اجتماع", "ميزانية"],
+                default=["الكل"]
+            )
+        
+        with col2:
+            priority_filter = st.multiselect(
+                "الأولوية",
+                options=["الكل", "عالية", "متوسطة", "منخفضة"],
+                default=["الكل"]
+            )
+        
+        with col3:
+            read_filter = st.radio(
+                "الحالة",
+                options=["الكل", "غير مقروءة", "مقروءة"],
+                horizontal=True
+            )
+        
+        # تطبيق الفلاتر
+        filtered_notifications = self.notifications_data
+        
+        # تحويل أنواع الإشعارات من الإنجليزية إلى العربية للفلترة
+        type_mapping = {
+            "موعد نهائي": "deadline",
+            "ترسية": "award",
+            "مستند": "document",
+            "تغيير": "change",
+            "تأخير": "delay",
+            "مرحلة": "milestone",
+            "طلب": "request",
+            "تحديث": "update",
+            "اجتماع": "meeting",
+            "ميزانية": "budget"
+        }
+        
+        # تحويل الأولويات من العربية إلى الإنجليزية للفلترة
+        priority_mapping = {
+            "عالية": "high",
+            "متوسطة": "medium",
+            "منخفضة": "low"
+        }
+        
+        if "الكل" not in type_filter and type_filter:
+            filtered_types = [type_mapping[t] for t in type_filter if t in type_mapping]
+            filtered_notifications = [n for n in filtered_notifications if n["type"] in filtered_types]
+        
+        if "الكل" not in priority_filter and priority_filter:
+            filtered_priorities = [priority_mapping[p] for p in priority_filter if p in priority_mapping]
+            filtered_notifications = [n for n in filtered_notifications if n["priority"] in filtered_priorities]
+        
+        if read_filter == "غير مقروءة":
+            filtered_notifications = [n for n in filtered_notifications if not n["is_read"]]
+        elif read_filter == "مقروءة":
+            filtered_notifications = [n for n in filtered_notifications if n["is_read"]]
+        
+        # عرض عدد الإشعارات غير المقروءة
+        unread_count = len([n for n in filtered_notifications if not n["is_read"]])
+        
+        st.markdown(f"**عدد الإشعارات غير المقروءة:** {unread_count}")
+        
+        # زر تحديث وتعليم الكل كمقروء
+        col1, col2 = st.columns([1, 1])
+        with col1:
+            if st.button("تحديث الإشعارات", use_container_width=True):
+                st.success("تم تحديث الإشعارات بنجاح")
+        
+        with col2:
+            if st.button("تعليم الكل كمقروء", use_container_width=True):
+                st.success("تم تعليم جميع الإشعارات كمقروءة")
+        
+        # عرض الإشعارات
+        if not filtered_notifications:
+            st.info("لا توجد إشعارات تطابق الفلاتر المحددة")
+        else:
+            for notification in filtered_notifications:
+                self.display_notification(notification)
+    
+    def display_notification(self, notification):
+        """عرض إشعار واحد"""
+        # تحديد لون الإشعار بناءً على الأولوية
+        if notification["priority"] == "high":
+            color = self.ui.COLORS['danger']
+            priority_text = "عالية"
+        elif notification["priority"] == "medium":
+            color = self.ui.COLORS['warning']
+            priority_text = "متوسطة"
+        else:
+            color = self.ui.COLORS['secondary']
+            priority_text = "منخفضة"
+        
+        # تحويل نوع الإشعار إلى العربية
+        type_mapping = {
+            "deadline": "موعد نهائي",
+            "award": "ترسية",
+            "document": "مستند",
+            "change": "تغيير",
+            "delay": "تأخير",
+            "milestone": "مرحلة",
+            "request": "طلب",
+            "update": "تحديث",
+            "meeting": "اجتماع",
+            "budget": "ميزانية"
+        }
+        
+        notification_type = type_mapping.get(notification["type"], notification["type"])
+        
+        # تحويل التاريخ إلى تنسيق مناسب
+        created_at = datetime.datetime.fromisoformat(notification["created_at"])
+        formatted_date = created_at.strftime("%Y-%m-%d %H:%M")
+        
+        # تحديد أيقونة الإشعار
+        icon_mapping = {
+            "deadline": "⏰",
+            "award": "🏆",
+            "document": "📄",
+            "change": "🔄",
+            "delay": "⚠️",
+            "milestone": "🏁",
+            "request": "❓",
+            "update": "🔄",
+            "meeting": "👥",
+            "budget": "💰"
+        }
+        
+        icon = icon_mapping.get(notification["type"], "📌")
+        
+        # إنشاء بطاقة الإشعار
+        st.markdown(
+            f"""
+            <div style="border-left: 5px solid {color}; padding: 10px; margin-bottom: 10px; background-color: {'#f8f9fa' if st.session_state.theme == 'light' else '#2b2b2b'}; border-radius: 5px; {'opacity: 0.7;' if notification['is_read'] else ''}">
+                <div style="display: flex; justify-content: space-between; align-items: center;">
+                    <div>
+                        <h4 style="margin: 0;">{icon} {notification['title']}</h4>
+                        <p style="margin: 5px 0;">{notification['message']}</p>
+                        <div style="display: flex; gap: 10px; font-size: 0.8em; color: {'#6c757d' if st.session_state.theme == 'light' else '#adb5bd'};">
+                            <span>النوع: {notification_type}</span>
+                            <span>الأولوية: {priority_text}</span>
+                            <span>التاريخ: {formatted_date}</span>
+                        </div>
+                    </div>
+                    <div>
+                        <button style="background: none; border: none; cursor: pointer; color: {'#6c757d' if st.session_state.theme == 'light' else '#adb5bd'};">✓</button>
+                        <button style="background: none; border: none; cursor: pointer; color: {'#6c757d' if st.session_state.theme == 'light' else '#adb5bd'};">🗑️</button>
+                    </div>
+                </div>
+            </div>
+            """,
+            unsafe_allow_html=True
+        )
+    
+    def show_notification_settings(self):
+        """عرض إعدادات الإشعارات"""
+        st.markdown("### إعدادات الإشعارات")
+        
+        # إنشاء نموذج الإعدادات
+        with st.form("notification_settings_form"):
+            st.markdown("#### أنواع الإشعارات")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                deadline = st.checkbox("المواعيد النهائية", value=self.notification_settings["deadline"])
+                award = st.checkbox("ترسية المناقصات", value=self.notification_settings["award"])
+                document = st.checkbox("تحديثات المستندات", value=self.notification_settings["document"])
+                change = st.checkbox("التغييرات في المواصفات", value=self.notification_settings["change"])
+                delay = st.checkbox("التأخيرات في المشاريع", value=self.notification_settings["delay"])
+            
+            with col2:
+                milestone = st.checkbox("اكتمال المراحل", value=self.notification_settings["milestone"])
+                request = st.checkbox("طلبات المعلومات", value=self.notification_settings["request"])
+                update = st.checkbox("تحديثات النظام", value=self.notification_settings["update"])
+                meeting = st.checkbox("الاجتماعات", value=self.notification_settings["meeting"])
+                budget = st.checkbox("تغييرات الميزانية", value=self.notification_settings["budget"])
+            
+            st.markdown("#### طرق الإشعار")
+            
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                email_notifications = st.checkbox("البريد الإلكتروني", value=self.notification_settings["email_notifications"])
+            
+            with col2:
+                sms_notifications = st.checkbox("الرسائل النصية", value=self.notification_settings["sms_notifications"])
+            
+            with col3:
+                push_notifications = st.checkbox("إشعارات الويب", value=self.notification_settings["push_notifications"])
+            
+            st.markdown("#### تكرار الإشعارات")
+            
+            notification_frequency = st.radio(
+                "تكرار الإشعارات",
+                options=["في الوقت الحقيقي", "مرة واحدة يومياً", "مرة واحدة أسبوعياً"],
+                index=0 if self.notification_settings["notification_frequency"] == "realtime" else 1 if self.notification_settings["notification_frequency"] == "daily" else 2,
+                horizontal=True
+            )
+            
+            # زر حفظ الإعدادات
+            submit_button = st.form_submit_button("حفظ الإعدادات")
+            
+            if submit_button:
+                # تحديث الإعدادات (في تطبيق حقيقي، سيتم حفظ الإعدادات في قاعدة البيانات)
+                self.notification_settings.update({
+                    "deadline": deadline,
+                    "award": award,
+                    "document": document,
+                    "change": change,
+                    "delay": delay,
+                    "milestone": milestone,
+                    "request": request,
+                    "update": update,
+                    "meeting": meeting,
+                    "budget": budget,
+                    "email_notifications": email_notifications,
+                    "sms_notifications": sms_notifications,
+                    "push_notifications": push_notifications,
+                    "notification_frequency": "realtime" if notification_frequency == "في الوقت الحقيقي" else "daily" if notification_frequency == "مرة واحدة يومياً" else "weekly"
+                })
+                
+                st.success("تم حفظ الإعدادات بنجاح")
+        
+        # إعدادات متقدمة
+        st.markdown("### إعدادات متقدمة")
+        
+        with st.expander("إعدادات متقدمة"):
+            st.markdown("#### جدولة الإشعارات")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.time_input("وقت الإشعارات اليومية", datetime.time(9, 0))
+            
+            with col2:
+                st.selectbox(
+                    "يوم الإشعارات الأسبوعية",
+                    options=["الأحد", "الاثنين", "الثلاثاء", "الأربعاء", "الخميس", "الجمعة", "السبت"],
+                    index=0
+                )
+            
+            st.markdown("#### فلترة الإشعارات")
+            
+            min_priority = st.select_slider(
+                "الحد الأدنى للأولوية",
+                options=["منخفضة", "متوسطة", "عالية"],
+                value="منخفضة"
+            )
+            
+            st.markdown("#### حفظ الإشعارات")
+            
+            retention_period = st.slider(
+                "فترة الاحتفاظ بالإشعارات (بالأيام)",
+                min_value=7,
+                max_value=365,
+                value=90,
+                step=1
+            )
+            
+            if st.button("حفظ الإعدادات المتقدمة"):
+                st.success("تم حفظ الإعدادات المتقدمة بنجاح")
+    
+    def create_notification(self):
+        """إنشاء إشعار جديد"""
+        st.markdown("### إنشاء إشعار جديد")
+        
+        # إنشاء نموذج إشعار جديد
+        with st.form("new_notification_form"):
+            title = st.text_input("عنوان الإشعار")
+            message = st.text_area("نص الإشعار")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                notification_type = st.selectbox(
+                    "نوع الإشعار",
+                    options=["موعد نهائي", "ترسية", "مستند", "تغيير", "تأخير", "مرحلة", "طلب", "تحديث", "اجتماع", "ميزانية"]
+                )
+                
+                # تحويل نوع الإشعار إلى الإنجليزية
+                type_mapping = {
+                    "موعد نهائي": "deadline",
+                    "ترسية": "award",
+                    "مستند": "document",
+                    "تغيير": "change",
+                    "تأخير": "delay",
+                    "مرحلة": "milestone",
+                    "طلب": "request",
+                    "تحديث": "update",
+                    "اجتماع": "meeting",
+                    "ميزانية": "budget"
+                }
+                
+                notification_type_en = type_mapping.get(notification_type, "deadline")
+                
+                priority = st.selectbox(
+                    "الأولوية",
+                    options=["عالية", "متوسطة", "منخفضة"]
+                )
+                
+                # تحويل الأولوية إلى الإنجليزية
+                priority_mapping = {
+                    "عالية": "high",
+                    "متوسطة": "medium",
+                    "منخفضة": "low"
+                }
+                
+                priority_en = priority_mapping.get(priority, "medium")
+            
+            with col2:
+                related_entity = st.text_input("الكيان المرتبط (مثل: رقم المناقصة، رقم المشروع)")
+                
+                notification_date = st.date_input(
+                    "تاريخ الإشعار",
+                    value=datetime.datetime.now().date()
+                )
+                
+                notification_time = st.time_input(
+                    "وقت الإشعار",
+                    value=datetime.datetime.now().time()
+                )
+            
+            # زر إنشاء الإشعار
+            submit_button = st.form_submit_button("إنشاء الإشعار")
+            
+            if submit_button and title and message:
+                # إنشاء إشعار جديد (في تطبيق حقيقي، سيتم حفظ الإشعار في قاعدة البيانات)
+                new_id = f"N{len(self.notifications_data) + 1:03d}"
+                
+                # تحويل التاريخ والوقت إلى تنسيق ISO
+                notification_datetime = datetime.datetime.combine(notification_date, notification_time)
+                notification_datetime_iso = notification_datetime.isoformat()
+                
+                # إضافة الإشعار الجديد إلى قائمة الإشعارات
+                self.notifications_data.append({
+                    "id": new_id,
+                    "title": title,
+                    "message": message,
+                    "type": notification_type_en,
+                    "priority": priority_en,
+                    "related_entity": related_entity,
+                    "created_at": notification_datetime_iso,
+                    "is_read": False
+                })
+                
+                st.success("تم إنشاء الإشعار بنجاح")
+                
+                # عرض الإشعار الجديد
+                st.markdown("### الإشعار الجديد")
+                self.display_notification(self.notifications_data[-1])
+        
+        # إنشاء إشعارات متعددة
+        st.markdown("### إنشاء إشعارات متعددة")
+        
+        with st.expander("إنشاء إشعارات متعددة"):
+            st.markdown("#### تحميل ملف إشعارات")
+            
+            uploaded_file = st.file_uploader("قم بتحميل ملف إشعارات (CSV, JSON)", type=["csv", "json"])
+            
+            if uploaded_file is not None:
+                if st.button("استيراد الإشعارات"):
+                    st.success("تم استيراد الإشعارات بنجاح")
+            
+            st.markdown("#### إنشاء إشعارات من قالب")
+            
+            template_type = st.selectbox(
+                "نوع القالب",
+                options=["إشعارات المواعيد النهائية", "إشعارات الاجتماعات", "إشعارات التحديثات"]
+            )
+            
+            if st.button("إنشاء إشعارات من القالب"):
+                st.success("تم إنشاء الإشعارات من القالب بنجاح")
+    
+    def show_notification_history(self):
+        """عرض سجل الإشعارات"""
+        st.markdown("### سجل الإشعارات")
+        
+        # إنشاء فلاتر للسجل
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            date_range = st.date_input(
+                "نطاق التاريخ",
+                value=(
+                    datetime.datetime.now().date() - datetime.timedelta(days=30),
+                    datetime.datetime.now().date()
+                )
+            )
+        
+        with col2:
+            entity_filter = st.text_input("الكيان المرتبط")
+        
+        # تحويل البيانات إلى DataFrame
+        notifications_df = pd.DataFrame(self.notifications_data)
+        
+        # تحويل عمود التاريخ إلى نوع datetime
+        notifications_df["created_at"] = pd.to_datetime(notifications_df["created_at"])
+        
+        # تطبيق فلتر التاريخ
+        if len(date_range) == 2:
+            start_date, end_date = date_range
+            start_date = pd.to_datetime(start_date)
+            end_date = pd.to_datetime(end_date) + pd.Timedelta(days=1) - pd.Timedelta(seconds=1)
+            
+            notifications_df = notifications_df[
+                (notifications_df["created_at"] >= start_date) &
+                (notifications_df["created_at"] <= end_date)
+            ]
+        
+        # تطبيق فلتر الكيان المرتبط
+        if entity_filter:
+            notifications_df = notifications_df[
+                notifications_df["related_entity"].str.contains(entity_filter, case=False)
+            ]
+        
+        # تحويل أنواع الإشعارات من الإنجليزية إلى العربية
+        type_mapping = {
+            "deadline": "موعد نهائي",
+            "award": "ترسية",
+            "document": "مستند",
+            "change": "تغيير",
+            "delay": "تأخير",
+            "milestone": "مرحلة",
+            "request": "طلب",
+            "update": "تحديث",
+            "meeting": "اجتماع",
+            "budget": "ميزانية"
+        }
+        
+        notifications_df["type_ar"] = notifications_df["type"].map(type_mapping)
+        
+        # تحويل الأولويات من الإنجليزية إلى العربية
+        priority_mapping = {
+            "high": "عالية",
+            "medium": "متوسطة",
+            "low": "منخفضة"
+        }
+        
+        notifications_df["priority_ar"] = notifications_df["priority"].map(priority_mapping)
+        
+        # تحويل حالة القراءة إلى نص
+        notifications_df["is_read_text"] = notifications_df["is_read"].map({True: "مقروءة", False: "غير مقروءة"})
+        
+        # تنسيق عمود التاريخ
+        notifications_df["created_at_formatted"] = notifications_df["created_at"].dt.strftime("%Y-%m-%d %H:%M")
+        
+        # إنشاء DataFrame للعرض
+        display_df = notifications_df[[
+            "id", "title", "type_ar", "priority_ar", "related_entity",
+            "created_at_formatted", "is_read_text"
+        ]].rename(columns={
+            "id": "الرقم",
+            "title": "العنوان",
+            "type_ar": "النوع",
+            "priority_ar": "الأولوية",
+            "related_entity": "الكيان المرتبط",
+            "created_at_formatted": "التاريخ",
+            "is_read_text": "الحالة"
+        })
+        
+        # عرض الجدول
+        st.dataframe(display_df, use_container_width=True, hide_index=True)
+        
+        # إحصائيات الإشعارات
+        st.markdown("### إحصائيات الإشعارات")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            total_count = len(notifications_df)
+            st.metric("إجمالي الإشعارات", total_count)
+        
+        with col2:
+            read_count = len(notifications_df[notifications_df["is_read"] == True])
+            st.metric("الإشعارات المقروءة", read_count)
+        
+        with col3:
+            unread_count = len(notifications_df[notifications_df["is_read"] == False])
+            st.metric("الإشعارات غير المقروءة", unread_count)
+        
+        # رسم بياني لتوزيع الإشعارات حسب النوع
+        st.markdown("#### توزيع الإشعارات حسب النوع")
+        
+        type_counts = notifications_df["type_ar"].value_counts().reset_index()
+        type_counts.columns = ["النوع", "العدد"]
+        
+        st.bar_chart(type_counts, x="النوع", y="العدد")
+        
+        # رسم بياني لتوزيع الإشعارات حسب الأولوية
+        st.markdown("#### توزيع الإشعارات حسب الأولوية")
+        
+        priority_counts = notifications_df["priority_ar"].value_counts().reset_index()
+        priority_counts.columns = ["الأولوية", "العدد"]
+        
+        st.bar_chart(priority_counts, x="الأولوية", y="العدد")
+        
+        # خيارات التصدير
+        st.markdown("### تصدير البيانات")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if st.button("تصدير إلى CSV"):
+                st.success("تم تصدير البيانات إلى CSV بنجاح")
+        
+        with col2:
+            if st.button("تصدير إلى Excel"):
+                st.success("تم تصدير البيانات إلى Excel بنجاح")

modules/pricing/price_analyzer.py

@@ -0,0 +1,1695 @@
+"""
+محلل الأسعار لنظام إدارة المناقصات
+"""
+
+import os
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime, timedelta
+from scipy import stats
+import logging
+
+logger = logging.getLogger('tender_system.pricing.analyzer')
+
+class PriceAnalyzer:
+    """فئة تحليل الأسعار"""
+    
+    def __init__(self, db_connector):
+        """تهيئة محلل الأسعار"""
+        self.db = db_connector
+        self.charts_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "data", "charts")
+        
+        # إنشاء مجلد الرسوم البيانية إذا لم يكن موجودًا
+        os.makedirs(self.charts_dir, exist_ok=True)
+    
+    def get_price_history(self, item_id, start_date=None, end_date=None):
+        """الحصول على تاريخ الأسعار لبند معين
+        
+        المعلمات:
+            item_id (int): معرف البند
+            start_date (str, optional): تاريخ البداية بتنسيق 'YYYY-MM-DD'
+            end_date (str, optional): تاريخ النهاية بتنسيق 'YYYY-MM-DD'
+            
+        العائد:
+            pandas.DataFrame: إطار بيانات يحتوي على تاريخ الأسعار
+        """
+        try:
+            query = """
+                SELECT 
+                    pih.id,
+                    pih.price,
+                    pih.price_date,
+                    pih.price_source,
+                    pih.notes,
+                    pib.code,
+                    pib.name,
+                    mu.name as unit_name,
+                    mu.symbol as unit_symbol
+                FROM 
+                    pricing_items_history pih
+                JOIN 
+                    pricing_items_base pib ON pih.base_item_id = pib.id
+                LEFT JOIN 
+                    measurement_units mu ON pib.unit_id = mu.id
+                WHERE 
+                    pih.base_item_id = ?
+            """
+            
+            params = [item_id]
+            
+            if start_date:
+                query += " AND pih.price_date >= ?"
+                params.append(start_date)
+            
+            if end_date:
+                query += " AND pih.price_date <= ?"
+                params.append(end_date)
+            
+            query += " ORDER BY pih.price_date ASC"
+            
+            results = self.db.fetch_all(query, params)
+            
+            if not results:
+                logger.warning(f"لا توجد بيانات تاريخية للسعر للبند رقم {item_id}")
+                return pd.DataFrame()
+            
+            # تحويل النتائج إلى إطار بيانات
+            df = pd.DataFrame(results, columns=[
+                'id', 'price', 'price_date', 'price_source', 'notes', 
+                'code', 'name', 'unit_name', 'unit_symbol'
+            ])
+            
+            # تحويل تاريخ السعر إلى نوع datetime
+            df['price_date'] = pd.to_datetime(df['price_date'])
+            
+            return df
+            
+        except Exception as e:
+            logger.error(f"خطأ في الحصول على تاريخ الأسعار: {str(e)}")
+            return pd.DataFrame()
+    
+    def analyze_price_trends(self, item_id, start_date=None, end_date=None):
+        """تحليل اتجاهات الأسعار
+        
+        المعلمات:
+            item_id (int): معرف البند
+            start_date (str, optional): تاريخ البداية بتنسيق 'YYYY-MM-DD'
+            end_date (str, optional): تاريخ النهاية بتنسيق 'YYYY-MM-DD'
+            
+        العائد:
+            dict: قاموس يحتوي على نتائج تحليل اتجاهات الأسعار
+        """
+        try:
+            # الحصول على تاريخ الأسعار
+            df = self.get_price_history(item_id, start_date, end_date)
+            
+            if df.empty:
+                return {
+                    'status': 'error',
+                    'message': 'لا توجد بيانات كافية لتحليل اتجاهات الأسعار'
+                }
+            
+            # حساب الإحصاءات الأساسية
+            stats_data = {
+                'min_price': df['price'].min(),
+                'max_price': df['price'].max(),
+                'avg_price': df['price'].mean(),
+                'median_price': df['price'].median(),
+                'std_dev': df['price'].std(),
+                'price_range': df['price'].max() - df['price'].min(),
+                'count': len(df),
+                'start_date': df['price_date'].min().strftime('%Y-%m-%d'),
+                'end_date': df['price_date'].max().strftime('%Y-%m-%d'),
+                'duration_days': (df['price_date'].max() - df['price_date'].min()).days,
+                'item_name': df['name'].iloc[0],
+                'item_code': df['code'].iloc[0],
+                'unit': df['unit_symbol'].iloc[0] if not pd.isna(df['unit_symbol'].iloc[0]) else ''
+            }
+            
+            # حساب التغير المطلق والنسبي
+            if len(df) >= 2:
+                first_price = df['price'].iloc[0]
+                last_price = df['price'].iloc[-1]
+                
+                stats_data['absolute_change'] = last_price - first_price
+                stats_data['percentage_change'] = ((last_price - first_price) / first_price) * 100
+                
+                # حساب معدل التغير السنوي
+                years = stats_data['duration_days'] / 365.0
+                if years > 0:
+                    stats_data['annual_change_rate'] = (((last_price / first_price) ** (1 / years)) - 1) * 100
+                else:
+                    stats_data['annual_change_rate'] = 0
+            else:
+                stats_data['absolute_change'] = 0
+                stats_data['percentage_change'] = 0
+                stats_data['annual_change_rate'] = 0
+            
+            # تحليل الاتجاه باستخدام الانحدار الخطي
+            if len(df) >= 3:
+                # إنشاء متغير مستقل (الأيام منذ أول تاريخ)
+                df['days'] = (df['price_date'] - df['price_date'].min()).dt.days
+                
+                # حساب الانحدار الخطي
+                slope, intercept, r_value, p_value, std_err = stats.linregress(df['days'], df['price'])
+                
+                stats_data['trend_slope'] = slope
+                stats_data['trend_intercept'] = intercept
+                stats_data['trend_r_squared'] = r_value ** 2
+                stats_data['trend_p_value'] = p_value
+                stats_data['trend_std_err'] = std_err
+                
+                # تحديد اتجاه السعر
+                if p_value < 0.05:  # إذا كان الاتجاه ذو دلالة إحصائية
+                    if slope > 0:
+                        stats_data['trend_direction'] = 'upward'
+                        stats_data['trend_description'] = 'اتجاه تصاعدي'
+                    elif slope < 0:
+                        stats_data['trend_direction'] = 'downward'
+                        stats_data['trend_description'] = 'اتجاه تنازلي'
+                    else:
+                        stats_data['trend_direction'] = 'stable'
+                        stats_data['trend_description'] = 'مستقر'
+                else:
+                    stats_data['trend_direction'] = 'no_significant_trend'
+                    stats_data['trend_description'] = 'لا يوجد اتجاه واضح'
+                
+                # حساب التقلب (معامل الاختلاف)
+                stats_data['volatility'] = (df['price'].std() / df['price'].mean()) * 100
+                
+                # تصنيف التقلب
+                if stats_data['volatility'] < 5:
+                    stats_data['volatility_level'] = 'low'
+                    stats_data['volatility_description'] = 'منخفض'
+                elif stats_data['volatility'] < 15:
+                    stats_data['volatility_level'] = 'medium'
+                    stats_data['volatility_description'] = 'متوسط'
+                else:
+                    stats_data['volatility_level'] = 'high'
+                    stats_data['volatility_description'] = 'مرتفع'
+            else:
+                stats_data['trend_direction'] = 'insufficient_data'
+                stats_data['trend_description'] = 'بيانات غير كافية'
+                stats_data['volatility'] = 0
+                stats_data['volatility_level'] = 'unknown'
+                stats_data['volatility_description'] = 'غير معروف'
+            
+            # إنشاء رسم بياني للاتجاه
+            chart_path = self._create_trend_chart(df, stats_data, item_id)
+            stats_data['chart_path'] = chart_path
+            
+            return {
+                'status': 'success',
+                'data': stats_data
+            }
+            
+        except Exception as e:
+            logger.error(f"خطأ في تحليل اتجاهات الأسعار: {str(e)}")
+            return {
+                'status': 'error',
+                'message': f'حدث خطأ أثناء تحليل اتجاهات الأسعار: {str(e)}'
+            }
+    
+    def _create_trend_chart(self, df, stats_data, item_id):
+        """إنشاء رسم بياني للاتجاه
+        
+        المعلمات:
+            df (pandas.DataFrame): إطار البيانات
+            stats_data (dict): بيانات الإحصاءات
+            item_id (int): معرف البند
+            
+        العائد:
+            str: مسار ملف الرسم البياني
+        """
+        try:
+            # إنشاء رسم بياني جديد
+            plt.figure(figsize=(10, 6))
+            
+            # رسم نقاط البيانات
+            plt.scatter(df['price_date'], df['price'], color='blue', alpha=0.6, label='أسعار فعلية')
+            
+            # رسم خط الاتجاه إذا كان هناك بيانات كافية
+            if len(df) >= 3 and 'trend_slope' in stats_data:
+                # إنشاء خط الاتجاه
+                x_trend = pd.date_range(start=df['price_date'].min(), end=df['price_date'].max(), periods=100)
+                days_trend = [(date - df['price_date'].min()).days for date in x_trend]
+                y_trend = stats_data['trend_slope'] * np.array(days_trend) + stats_data['trend_intercept']
+                
+                # رسم خط الاتجاه
+                plt.plot(x_trend, y_trend, color='red', linestyle='--', label='خط الاتجاه')
+            
+            # رسم خط متوسط السعر
+            plt.axhline(y=stats_data['avg_price'], color='green', linestyle='-', alpha=0.5, label='متوسط السعر')
+            
+            # إضافة عنوان ومحاور
+            plt.title(f"تحليل اتجاه السعر - {stats_data['item_name']} ({stats_data['item_code']})")
+            plt.xlabel('التاريخ')
+            plt.ylabel(f"السعر ({stats_data['unit']})")
+            
+            # إضافة شبكة
+            plt.grid(True, linestyle='--', alpha=0.7)
+            
+            # إضافة وسيلة إيضاح
+            plt.legend()
+            
+            # تنسيق التاريخ على المحور السيني
+            plt.gcf().autofmt_xdate()
+            
+            # إضافة معلومات إحصائية
+            info_text = (
+                f"التغير: {stats_data['percentage_change']:.2f}%\n"
+                f"التقلب: {stats_data['volatility']:.2f}%\n"
+            )
+            
+            if 'trend_r_squared' in stats_data:
+                info_text += f"R²: {stats_data['trend_r_squared']:.3f}"
+            
+            plt.annotate(info_text, xy=(0.02, 0.95), xycoords='axes fraction', 
+                        bbox=dict(boxstyle="round,pad=0.3", fc="white", ec="gray", alpha=0.8))
+            
+            # حفظ الرسم البياني
+            chart_filename = f"price_trend_{item_id}_{datetime.now().strftime('%Y%m%d%H%M%S')}.png"
+            chart_path = os.path.join(self.charts_dir, chart_filename)
+            plt.savefig(chart_path, dpi=100, bbox_inches='tight')
+            plt.close()
+            
+            return chart_path
+            
+        except Exception as e:
+            logger.error(f"خطأ في إنشاء رسم بياني للاتجاه: {str(e)}")
+            return None
+    
+    def compare_prices(self, items, date=None):
+        """مقارنة الأسعار بين عدة بنود
+        
+        المعلمات:
+            items (list): قائمة بمعرفات البنود
+            date (str, optional): تاريخ المقارنة بتنسيق 'YYYY-MM-DD'
+            
+        العائد:
+            dict: قاموس يحتوي على نتائج مقارنة الأسعار
+        """
+        try:
+            if not items:
+                return {
+                    'status': 'error',
+                    'message': 'لم يتم تحديد أي بنود للمقارنة'
+                }
+            
+            comparison_data = []
+            
+            for item_id in items:
+                # الحصول على معلومات البند الأساسية
+                item_query = """
+                    SELECT 
+                        id, code, name, description, 
+                        (SELECT name FROM measurement_units WHERE id = unit_id) as unit_name,
+                        (SELECT symbol FROM measurement_units WHERE id = unit_id) as unit_symbol,
+                        base_price, last_updated_date
+                    FROM 
+                        pricing_items_base
+                    WHERE 
+                        id = ?
+                """
+                
+                item_result = self.db.fetch_one(item_query, [item_id])
+                
+                if not item_result:
+                    logger.warning(f"البند رقم {item_id} غير موجود")
+                    continue
+                
+                item_data = {
+                    'id': item_result[0],
+                    'code': item_result[1],
+                    'name': item_result[2],
+                    'description': item_result[3],
+                    'unit_name': item_result[4],
+                    'unit_symbol': item_result[5],
+                    'base_price': item_result[6],
+                    'last_updated_date': item_result[7]
+                }
+                
+                # إذا تم تحديد تاريخ، نبحث عن السعر في ذلك التاريخ
+                if date:
+                    price_query = """
+                        SELECT price, price_date, price_source
+                        FROM pricing_items_history
+                        WHERE base_item_id = ?
+                        AND price_date <= ?
+                        ORDER BY price_date DESC
+                        LIMIT 1
+                    """
+                    
+                    price_result = self.db.fetch_one(price_query, [item_id, date])
+                    
+                    if price_result:
+                        item_data['price'] = price_result[0]
+                        item_data['price_date'] = price_result[1]
+                        item_data['price_source'] = price_result[2]
+                    else:
+                        # إذا لم يتم العثور على سعر في التاريخ المحدد، نستخدم السعر الأساسي
+                        item_data['price'] = item_data['base_price']
+                        item_data['price_date'] = item_data['last_updated_date']
+                        item_data['price_source'] = 'base_price'
+                else:
+                    # إذا لم يتم تحديد تاريخ، نستخدم أحدث سعر
+                    price_query = """
+                        SELECT price, price_date, price_source
+                        FROM pricing_items_history
+                        WHERE base_item_id = ?
+                        ORDER BY price_date DESC
+                        LIMIT 1
+                    """
+                    
+                    price_result = self.db.fetch_one(price_query, [item_id])
+                    
+                    if price_result:
+                        item_data['price'] = price_result[0]
+                        item_data['price_date'] = price_result[1]
+                        item_data['price_source'] = price_result[2]
+                    else:
+                        # إذا لم يتم العثور على سعر، نستخدم السعر الأساسي
+                        item_data['price'] = item_data['base_price']
+                        item_data['price_date'] = item_data['last_updated_date']
+                        item_data['price_source'] = 'base_price'
+                
+                comparison_data.append(item_data)
+            
+            if not comparison_data:
+                return {
+                    'status': 'error',
+                    'message': 'لم يتم العثور على أي بنود للمقارنة'
+                }
+            
+            # إنشاء رسم بياني للمقارنة
+            chart_path = self._create_comparison_chart(comparison_data, date)
+            
+            return {
+                'status': 'success',
+                'data': {
+                    'items': comparison_data,
+                    'comparison_date': date if date else 'latest',
+                    'chart_path': chart_path
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"خطأ في مقارنة الأسعار: {str(e)}")
+            return {
+                'status': 'error',
+                'message': f'حدث خطأ أثناء مقارنة الأسعار: {str(e)}'
+            }
+    
+    def _create_comparison_chart(self, comparison_data, date=None):
+        """إنشاء رسم بياني للمقارنة
+        
+        المعلمات:
+            comparison_data (list): بيانات المقارنة
+            date (str, optional): تاريخ المقارنة
+            
+        العائد:
+            str: مسار ملف الرسم البياني
+        """
+        try:
+            # إنشاء رسم بياني جديد
+            plt.figure(figsize=(12, 6))
+            
+            # إعداد البيانات للرسم
+            names = [f"{item['code']} - {item['name']}" for item in comparison_data]
+            prices = [item['price'] for item in comparison_data]
+            
+            # رسم الأعمدة
+            bars = plt.bar(names, prices, color='skyblue', edgecolor='navy')
+            
+            # إضافة القيم فوق الأعمدة
+            for bar in bars:
+                height = bar.get_height()
+                plt.text(bar.get_x() + bar.get_width()/2., height + 0.1,
+                        f'{height:.2f}', ha='center', va='bottom')
+            
+            # إضافة عنوان ومحاور
+            title = "مقارنة الأسعار"
+            if date:
+                title += f" (بتاريخ {date})"
+            
+            plt.title(title)
+            plt.xlabel('البنود')
+            plt.ylabel('السعر')
+            
+            # تدوير تسميات المحور السيني لتجنب التداخل
+            plt.xticks(rotation=45, ha='right')
+            
+            # إضافة شبكة
+            plt.grid(True, linestyle='--', alpha=0.7, axis='y')
+            
+            # ضبط التخطيط
+            plt.tight_layout()
+            
+            # حفظ الرسم البياني
+            chart_filename = f"price_comparison_{datetime.now().strftime('%Y%m%d%H%M%S')}.png"
+            chart_path = os.path.join(self.charts_dir, chart_filename)
+            plt.savefig(chart_path, dpi=100, bbox_inches='tight')
+            plt.close()
+            
+            return chart_path
+            
+        except Exception as e:
+            logger.error(f"خطأ في إنشاء رسم بياني للمقارنة: {str(e)}")
+            return None
+    
+    def calculate_price_volatility(self, item_id, period='1y'):
+        """حساب تقلب الأسعار
+        
+        المعلمات:
+            item_id (int): معرف البند
+            period (str): الفترة الزمنية ('1m', '3m', '6m', '1y', '2y', '5y', 'all')
+            
+        العائد:
+            dict: قاموس يحتوي على نتائج حساب تقلب الأسعار
+        """
+        try:
+            # تحديد تاريخ البداية بناءً على الفترة
+            end_date = datetime.now().strftime('%Y-%m-%d')
+            
+            if period == '1m':
+                start_date = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d')
+            elif period == '3m':
+                start_date = (datetime.now() - timedelta(days=90)).strftime('%Y-%m-%d')
+            elif period == '6m':
+                start_date = (datetime.now() - timedelta(days=180)).strftime('%Y-%m-%d')
+            elif period == '1y':
+                start_date = (datetime.now() - timedelta(days=365)).strftime('%Y-%m-%d')
+            elif period == '2y':
+                start_date = (datetime.now() - timedelta(days=730)).strftime('%Y-%m-%d')
+            elif period == '5y':
+                start_date = (datetime.now() - timedelta(days=1825)).strftime('%Y-%m-%d')
+            else:  # 'all'
+                start_date = None
+            
+            # الحصول على تاريخ الأسعار
+            df = self.get_price_history(item_id, start_date, end_date)
+            
+            if df.empty or len(df) < 2:
+                return {
+                    'status': 'error',
+                    'message': 'لا توجد بيانات كافية لحساب تقلب الأسعار'
+                }
+            
+            # حساب التقلب (معامل الاختلاف)
+            mean_price = df['price'].mean()
+            std_dev = df['price'].std()
+            volatility = (std_dev / mean_price) * 100
+            
+            # حساب التغيرات النسبية
+            df['price_shift'] = df['price'].shift(1)
+            df = df.dropna()
+            
+            if not df.empty:
+                df['price_change_pct'] = ((df['price'] - df['price_shift']) / df['price_shift']) * 100
+                
+                # حساب إحصاءات التغيرات
+                max_increase = df['price_change_pct'].max()
+                max_decrease = df['price_change_pct'].min()
+                avg_change = df['price_change_pct'].mean()
+                median_change = df['price_change_pct'].median()
+                
+                # حساب عدد التغيرات الإيجابية والسلبية
+                positive_changes = (df['price_change_pct'] > 0).sum()
+                negative_changes = (df['price_change_pct'] < 0).sum()
+                no_changes = (df['price_change_pct'] == 0).sum()
+                
+                # تصنيف التقلب
+                if volatility < 5:
+                    volatility_level = 'low'
+                    volatility_description = 'منخفض'
+                elif volatility < 15:
+                    volatility_level = 'medium'
+                    volatility_description = 'متوسط'
+                else:
+                    volatility_level = 'high'
+                    volatility_description = 'مرتفع'
+                
+                # إنشاء رسم بياني للتقلب
+                chart_path = self._create_volatility_chart(df, item_id, period)
+                
+                return {
+                    'status': 'success',
+                    'data': {
+                        'item_id': item_id,
+                        'item_name': df['name'].iloc[0],
+                        'item_code': df['code'].iloc[0],
+                        'period': period,
+                        'start_date': df['price_date'].min().strftime('%Y-%m-%d'),
+                        'end_date': df['price_date'].max().strftime('%Y-%m-%d'),
+                        'data_points': len(df),
+                        'mean_price': mean_price,
+                        'std_dev': std_dev,
+                        'volatility': volatility,
+                        'volatility_level': volatility_level,
+                        'volatility_description': volatility_description,
+                        'max_increase': max_increase,
+                        'max_decrease': max_decrease,
+                        'avg_change': avg_change,
+                        'median_change': median_change,
+                        'positive_changes': positive_changes,
+                        'negative_changes': negative_changes,
+                        'no_changes': no_changes,
+                        'chart_path': chart_path
+                    }
+                }
+            else:
+                return {
+                    'status': 'error',
+                    'message': 'لا توجد بيانات كافية لحساب تقلب الأسعار بعد معالجة البيانات'
+                }
+            
+        except Exception as e:
+            logger.error(f"خطأ في حساب تقلب الأسعار: {str(e)}")
+            return {
+                'status': 'error',
+                'message': f'حدث خطأ أثناء حساب تقلب الأسعار: {str(e)}'
+            }
+    
+    def _create_volatility_chart(self, df, item_id, period):
+        """إنشاء رسم بياني للتقلب
+        
+        المعلمات:
+            df (pandas.DataFrame): إطار البيانات
+            item_id (int): معرف البند
+            period (str): الفترة الزمنية
+            
+        العائد:
+            str: مسار ملف الرسم البياني
+        """
+        try:
+            # إنشاء رسم بياني بمحورين
+            fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10), gridspec_kw={'height_ratios': [2, 1]})
+            
+            # الرسم البياني العلوي: سعر البند عبر الزمن
+            ax1.plot(df['price_date'], df['price'], 'b-', linewidth=2)
+            ax1.set_title(f"سعر البند عبر الزمن - {df['name'].iloc[0]} ({df['code'].iloc[0]})")
+            ax1.set_xlabel('التاريخ')
+            ax1.set_ylabel('السعر')
+            ax1.grid(True, linestyle='--', alpha=0.7)
+            
+            # إضافة نطاق الانحراف المعياري
+            mean_price = df['price'].mean()
+            std_dev = df['price'].std()
+            
+            ax1.axhline(y=mean_price, color='g', linestyle='-', alpha=0.8, label='متوسط السعر')
+            ax1.axhline(y=mean_price + std_dev, color='r', linestyle='--', alpha=0.5, label='انحراف معياري +1')
+            ax1.axhline(y=mean_price - std_dev, color='r', linestyle='--', alpha=0.5, label='انحراف معياري -1')
+            
+            ax1.fill_between(df['price_date'], mean_price - std_dev, mean_price + std_dev, color='gray', alpha=0.2)
+            ax1.legend()
+            
+            # الرسم البياني السفلي: التغيرات النسبية
+            ax2.bar(df['price_date'], df['price_change_pct'], color='skyblue', edgecolor='navy', alpha=0.7)
+            ax2.set_title('التغيرات النسبية في السعر (%)')
+            ax2.set_xlabel('التاريخ')
+            ax2.set_ylabel('التغير النسبي (%)')
+            ax2.grid(True, linestyle='--', alpha=0.7)
+            
+            # إضافة خط الصفر
+            ax2.axhline(y=0, color='k', linestyle='-', alpha=0.3)
+            
+            # تنسيق التاريخ على المحور السيني
+            fig.autofmt_xdate()
+            
+            # ضبط التخطيط
+            plt.tight_layout()
+            
+            # حفظ الرسم البياني
+            chart_filename = f"price_volatility_{item_id}_{period}_{datetime.now().strftime('%Y%m%d%H%M%S')}.png"
+            chart_path = os.path.join(self.charts_dir, chart_filename)
+            plt.savefig(chart_path, dpi=100, bbox_inches='tight')
+            plt.close()
+            
+            return chart_path
+            
+        except Exception as e:
+            logger.error(f"خطأ في إنشاء رسم بياني للتقلب: {str(e)}")
+            return None
+    
+    def perform_sensitivity_analysis(self, project_id, variable_items, ranges):
+        """إجراء تحليل الحساسية
+        
+        المعلمات:
+            project_id (int): معرف المشروع
+            variable_items (list): قائمة بمعرفات البنود المتغيرة
+            ranges (dict): نطاقات التغيير لكل بند
+            
+        العائد:
+            dict: قاموس يحتوي على نتائج تحليل الحساسية
+        """
+        try:
+            # الحصول على بنود المشروع
+            query = """
+                SELECT 
+                    id, item_number, description, quantity, unit_price, total_price
+                FROM 
+                    project_pricing_items
+                WHERE 
+                    project_id = ?
+            """
+            
+            results = self.db.fetch_all(query, [project_id])
+            
+            if not results:
+                return {
+                    'status': 'error',
+                    'message': 'لا توجد بنود للمشروع المحدد'
+                }
+            
+            # تحويل النتائج إلى إطار بيانات
+            project_items = pd.DataFrame(results, columns=[
+                'id', 'item_number', 'description', 'quantity', 'unit_price', 'total_price'
+            ])
+            
+            # حساب إجمالي المشروع الأصلي
+            original_total = project_items['total_price'].sum()
+            
+            # تحضير بيانات تحليل الحساسية
+            sensitivity_data = []
+            
+            for item_id in variable_items:
+                if item_id not in project_items['id'].values:
+                    logger.warning(f"البند رقم {item_id} غير موجود في المشروع")
+                    continue
+                
+                # الحصول على معلومات البند
+                item_info = project_items[project_items['id'] == item_id].iloc[0]
+                
+                # الحصول على نطاق التغيير للبند
+                if str(item_id) in ranges:
+                    item_range = ranges[str(item_id)]
+                else:
+                    # استخدام نطاق افتراضي إذا لم يتم تحديد نطاق
+                    item_range = {'min': -20, 'max': 20, 'step': 10}
+                
+                # إنشاء قائمة بنسب التغيير
+                change_percentages = list(range(
+                    item_range['min'], 
+                    item_range['max'] + item_range['step'], 
+                    item_range['step']
+                ))
+                
+                item_sensitivity = {
+                    'item_id': item_id,
+                    'item_number': item_info['item_number'],
+                    'description': item_info['description'],
+                    'original_price': item_info['unit_price'],
+                    'original_total': item_info['total_price'],
+                    'changes': []
+                }
+                
+                # حساب تأثير كل نسبة تغيير
+                for percentage in change_percentages:
+                    # حساب السعر الجديد
+                    new_price = item_info['unit_price'] * (1 + percentage / 100)
+                    new_total = new_price * item_info['quantity']
+                    
+                    # حساب إجمالي المشروع الجديد
+                    project_total = original_total - item_info['total_price'] + new_total
+                    
+                    # حساب التغير في إجمالي المشروع
+                    project_change = ((project_total - original_total) / original_total) * 100
+                    
+                    item_sensitivity['changes'].append({
+                        'percentage': percentage,
+                        'new_price': new_price,
+                        'new_total': new_total,
+                        'project_total': project_total,
+                        'project_change': project_change
+                    })
+                
+                sensitivity_data.append(item_sensitivity)
+            
+            if not sensitivity_data:
+                return {
+                    'status': 'error',
+                    'message': 'لا توجد بنود صالحة لتحليل الحساسية'
+                }
+            
+            # إنشاء رسم بياني لتحليل الحساسية
+            chart_path = self._create_sensitivity_chart(sensitivity_data, original_total, project_id)
+            
+            return {
+                'status': 'success',
+                'data': {
+                    'project_id': project_id,
+                    'original_total': original_total,
+                    'sensitivity_data': sensitivity_data,
+                    'chart_path': chart_path
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"خطأ في إجراء تحليل الحساسية: {str(e)}")
+            return {
+                'status': 'error',
+                'message': f'حدث خطأ أثناء إجراء تحليل الحساسية: {str(e)}'
+            }
+    
+    def _create_sensitivity_chart(self, sensitivity_data, original_total, project_id):
+        """إنشاء رسم بياني لتحليل الحساسية
+        
+        المعلمات:
+            sensitivity_data (list): بيانات تحليل الحساسية
+            original_total (float): إجمالي المشروع الأصلي
+            project_id (int): معرف المشروع
+            
+        العائد:
+            str: مسار ملف الرسم البياني
+        """
+        try:
+            # إنشاء رسم بياني جديد
+            plt.figure(figsize=(12, 8))
+            
+            # رسم خطوط الحساسية لكل بند
+            for item in sensitivity_data:
+                percentages = [change['percentage'] for change in item['changes']]
+                project_changes = [change['project_change'] for change in item['changes']]
+                
+                plt.plot(percentages, project_changes, marker='o', linewidth=2, 
+                        label=f"{item['item_number']} - {item['description'][:30]}...")
+            
+            # إضافة عنوان ومحاور
+            plt.title(f"تحليل الحساسية للمشروع رقم {project_id}")
+            plt.xlabel('نسبة التغيير في سعر البند (%)')
+            plt.ylabel('نسبة التغيير في إجمالي المشروع (%)')
+            
+            # إضافة خط الصفر
+            plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)
+            plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)
+            
+            # إضافة شبكة
+            plt.grid(True, linestyle='--', alpha=0.7)
+            
+            # إضافة وسيلة إيضاح
+            plt.legend(loc='best')
+            
+            # إضافة معلومات إضافية
+            info_text = f"إجمالي المشروع الأصلي: {original_total:,.2f}"
+            plt.annotate(info_text, xy=(0.02, 0.02), xycoords='axes fraction', 
+                        bbox=dict(boxstyle="round,pad=0.3", fc="white", ec="gray", alpha=0.8))
+            
+            # ضبط التخطيط
+            plt.tight_layout()
+            
+            # حفظ الرسم البياني
+            chart_filename = f"sensitivity_analysis_{project_id}_{datetime.now().strftime('%Y%m%d%H%M%S')}.png"
+            chart_path = os.path.join(self.charts_dir, chart_filename)
+            plt.savefig(chart_path, dpi=100, bbox_inches='tight')
+            plt.close()
+            
+            return chart_path
+            
+        except Exception as e:
+            logger.error(f"خطأ في إنشاء رسم بياني لتحليل الحساسية: {str(e)}")
+            return None
+    
+    def analyze_price_correlations(self, items):
+        """تحليل ارتباطات الأسعار بين عدة بنود
+        
+        المعلمات:
+            items (list): قائمة بمعرفات البنود
+            
+        العائد:
+            dict: قاموس يحتوي على نتائج تحليل الارتباطات
+        """
+        try:
+            if not items or len(items) < 2:
+                return {
+                    'status': 'error',
+                    'message': 'يجب تحديد بندين على الأقل لتحليل الارتباطات'
+                }
+            
+            # جمع بيانات الأسعار لجميع البنود
+            all_prices = {}
+            item_names = {}
+            
+            for item_id in items:
+                # الحصول على تاريخ الأسعار
+                df = self.get_price_history(item_id)
+                
+                if df.empty:
+                    logger.warning(f"لا توجد بيانات تاريخية للسعر للبند رقم {item_id}")
+                    continue
+                
+                # تخزين بيانات الأسعار
+                all_prices[item_id] = df[['price_date', 'price']].copy()
+                item_names[item_id] = f"{df['code'].iloc[0]} - {df['name'].iloc[0]}"
+            
+            if len(all_prices) < 2:
+                return {
+                    'status': 'error',
+                    'message': 'لا توجد بيانات كافية لتحليل الارتباطات'
+                }
+            
+            # إنشاء إطار بيانات موحد بتواريخ مشتركة
+            # أولاً، نجمع جميع التواريخ الفريدة
+            all_dates = set()
+            for item_id, df in all_prices.items():
+                all_dates.update(df['price_date'].dt.strftime('%Y-%m-%d').tolist())
+            
+            # إنشاء إطار بيانات جديد بجميع التواريخ
+            unified_df = pd.DataFrame({'price_date': sorted(list(all_dates))})
+            unified_df['price_date'] = pd.to_datetime(unified_df['price_date'])
+            
+            # إضافة أسعار كل بند
+            for item_id, df in all_prices.items():
+                # تحويل إطار البيانات إلى سلسلة زمنية مفهرسة بالتاريخ
+                price_series = df.set_index('price_date')['price']
+                
+                # إعادة فهرسة السلسلة الزمنية لتتوافق مع التواريخ الموحدة
+                unified_df[f'price_{item_id}'] = unified_df['price_date'].map(
+                    lambda x: price_series.get(x, None)
+                )
+            
+            # ملء القيم المفقودة باستخدام الاستيفاء الخطي
+            price_columns = [col for col in unified_df.columns if col.startswith('price_')]
+            unified_df[price_columns] = unified_df[price_columns].interpolate(method='linear')
+            
+            # حذف الصفوف التي لا تزال تحتوي على قيم مفقودة
+            unified_df = unified_df.dropna()
+            
+            if len(unified_df) < 3:
+                return {
+                    'status': 'error',
+                    'message': 'لا توجد بيانات كافية بعد معالجة التواريخ المشتركة'
+                }
+            
+            # حساب مصفوفة الارتباط
+            correlation_matrix = unified_df[price_columns].corr()
+            
+            # تحويل مصفوفة الارتباط إلى تنسيق أكثر قابلية للقراءة
+            correlation_data = []
+            
+            for i, item1_id in enumerate(items):
+                if f'price_{item1_id}' not in correlation_matrix.columns:
+                    continue
+                    
+                for j, item2_id in enumerate(items):
+                    if f'price_{item2_id}' not in correlation_matrix.columns or i >= j:
+                        continue
+                    
+                    correlation = correlation_matrix.loc[f'price_{item1_id}', f'price_{item2_id}']
+                    
+                    # تحديد قوة واتجاه الارتباط
+                    if abs(correlation) < 0.3:
+                        strength = 'weak'
+                        strength_description = 'ضعيف'
+                    elif abs(correlation) < 0.7:
+                        strength = 'moderate'
+                        strength_description = 'متوسط'
+                    else:
+                        strength = 'strong'
+                        strength_description = 'قوي'
+                    
+                    if correlation > 0:
+                        direction = 'positive'
+                        direction_description = 'طردي'
+                    else:
+                        direction = 'negative'
+                        direction_description = 'عكسي'
+                    
+                    correlation_data.append({
+                        'item1_id': item1_id,
+                        'item1_name': item_names.get(item1_id, f'البند {item1_id}'),
+                        'item2_id': item2_id,
+                        'item2_name': item_names.get(item2_id, f'البند {item2_id}'),
+                        'correlation': correlation,
+                        'strength': strength,
+                        'strength_description': strength_description,
+                        'direction': direction,
+                        'direction_description': direction_description
+                    })
+            
+            if not correlation_data:
+                return {
+                    'status': 'error',
+                    'message': 'لم يتم العثور على ارتباطات بين البنود المحددة'
+                }
+            
+            # إنشاء رسم بياني للارتباطات
+            chart_path = self._create_correlation_chart(correlation_matrix, item_names)
+            
+            # إنشاء رسم بياني لتطور الأسعار
+            trends_chart_path = self._create_price_trends_chart(unified_df, price_columns, item_names)
+            
+            return {
+                'status': 'success',
+                'data': {
+                    'correlation_data': correlation_data,
+                    'chart_path': chart_path,
+                    'trends_chart_path': trends_chart_path
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"خطأ في تحليل ارتباطات الأسعار: {str(e)}")
+            return {
+                'status': 'error',
+                'message': f'حدث خطأ أثناء تحليل ارتباطات الأسعار: {str(e)}'
+            }
+    
+    def _create_correlation_chart(self, correlation_matrix, item_names):
+        """إنشاء رسم بياني لمصفوفة الارتباط
+        
+        المعلمات:
+            correlation_matrix (pandas.DataFrame): مصفوفة الارتباط
+            item_names (dict): قاموس بأسماء البنود
+            
+        العائد:
+            str: مسار ملف الرسم البياني
+        """
+        try:
+            # إنشاء رسم بياني جديد
+            plt.figure(figsize=(10, 8))
+            
+            # إنشاء خريطة حرارية للارتباطات
+            mask = np.triu(np.ones_like(correlation_matrix, dtype=bool))
+            cmap = sns.diverging_palette(230, 20, as_cmap=True)
+            
+            # تعديل تسميات المحاور
+            labels = [item_names.get(int(col.split('_')[1]), col) for col in correlation_matrix.columns]
+            
+            # رسم الخريطة الحرارية
+            sns.heatmap(correlation_matrix, mask=mask, cmap=cmap, vmax=1, vmin=-1, center=0,
+                        square=True, linewidths=.5, cbar_kws={"shrink": .5}, annot=True,
+                        xticklabels=labels, yticklabels=labels)
+            
+            # إضافة عنوان
+            plt.title('مصفوفة ارتباط الأسعار بين البنود')
+            
+            # ضبط التخطيط
+            plt.tight_layout()
+            
+            # حفظ الرسم البياني
+            chart_filename = f"price_correlation_{datetime.now().strftime('%Y%m%d%H%M%S')}.png"
+            chart_path = os.path.join(self.charts_dir, chart_filename)
+            plt.savefig(chart_path, dpi=100, bbox_inches='tight')
+            plt.close()
+            
+            return chart_path
+            
+        except Exception as e:
+            logger.error(f"خطأ في إنشاء رسم بياني لمصفوفة الارتباط: {str(e)}")
+            return None
+    
+    def _create_price_trends_chart(self, unified_df, price_columns, item_names):
+        """إنشاء رسم بياني لتطور الأسعار
+        
+        المعلمات:
+            unified_df (pandas.DataFrame): إطار البيانات الموحد
+            price_columns (list): أسماء أعمدة الأسعار
+            item_names (dict): قاموس بأسماء البنود
+            
+        العائد:
+            str: مسار ملف الرسم البياني
+        """
+        try:
+            # إنشاء رسم بياني جديد
+            plt.figure(figsize=(12, 6))
+            
+            # رسم تطور الأسعار لكل بند
+            for col in price_columns:
+                item_id = int(col.split('_')[1])
+                item_name = item_names.get(item_id, f'البند {item_id}')
+                
+                # تطبيع الأسعار للمقارنة (القيمة الأولى = 100)
+                first_price = unified_df[col].iloc[0]
+                normalized_prices = (unified_df[col] / first_price) * 100
+                
+                plt.plot(unified_df['price_date'], normalized_prices, linewidth=2, label=item_name)
+            
+            # إضافة عنوان ومحاور
+            plt.title('تطور الأسعار النسبية للبنود (القيمة الأولى = 100)')
+            plt.xlabel('التاريخ')
+            plt.ylabel('السعر النسبي')
+            
+            # إضافة شبكة
+            plt.grid(True, linestyle='--', alpha=0.7)
+            
+            # إضافة وسيلة إيضاح
+            plt.legend(loc='best')
+            
+            # تنسيق التاريخ على المحور السيني
+            plt.gcf().autofmt_xdate()
+            
+            # ضبط التخطيط
+            plt.tight_layout()
+            
+            # حفظ الرسم البياني
+            chart_filename = f"price_trends_{datetime.now().strftime('%Y%m%d%H%M%S')}.png"
+            chart_path = os.path.join(self.charts_dir, chart_filename)
+            plt.savefig(chart_path, dpi=100, bbox_inches='tight')
+            plt.close()
+            
+            return chart_path
+            
+        except Exception as e:
+            logger.error(f"خطأ في إنشاء رسم بياني لتطور الأسعار: {str(e)}")
+            return None
+    
+    def compare_with_market_prices(self, items):
+        """مقارنة أسعار البنود مع أسعار السوق
+        
+        المعلمات:
+            items (list): قائمة بمعرفات البنود
+            
+        العائد:
+            dict: قاموس يحتوي على نتائج المقارنة
+        """
+        try:
+            if not items:
+                return {
+                    'status': 'error',
+                    'message': 'لم يتم تحديد أي بنود للمقارنة'
+                }
+            
+            comparison_data = []
+            
+            for item_id in items:
+                # الحصول على معلومات البند الأساسية
+                item_query = """
+                    SELECT 
+                        id, code, name, description, 
+                        (SELECT name FROM measurement_units WHERE id = unit_id) as unit_name,
+                        (SELECT symbol FROM measurement_units WHERE id = unit_id) as unit_symbol,
+                        base_price, last_updated_date
+                    FROM 
+                        pricing_items_base
+                    WHERE 
+                        id = ?
+                """
+                
+                item_result = self.db.fetch_one(item_query, [item_id])
+                
+                if not item_result:
+                    logger.warning(f"البند رقم {item_id} غير موجود")
+                    continue
+                
+                item_data = {
+                    'id': item_result[0],
+                    'code': item_result[1],
+                    'name': item_result[2],
+                    'description': item_result[3],
+                    'unit_name': item_result[4],
+                    'unit_symbol': item_result[5],
+                    'base_price': item_result[6],
+                    'last_updated_date': item_result[7]
+                }
+                
+                # الحصول على أحدث سعر للبند
+                price_query = """
+                    SELECT price, price_date, price_source
+                    FROM pricing_items_history
+                    WHERE base_item_id = ?
+                    ORDER BY price_date DESC
+                    LIMIT 1
+                """
+                
+                price_result = self.db.fetch_one(price_query, [item_id])
+                
+                if price_result:
+                    item_data['current_price'] = price_result[0]
+                    item_data['price_date'] = price_result[1]
+                    item_data['price_source'] = price_result[2]
+                else:
+                    # إذا لم يتم العثور على سعر، نستخدم السعر الأساسي
+                    item_data['current_price'] = item_data['base_price']
+                    item_data['price_date'] = item_data['last_updated_date']
+                    item_data['price_source'] = 'base_price'
+                
+                # الحصول على متوسط سعر السوق (من مصادر مختلفة)
+                market_query = """
+                    SELECT AVG(price) as avg_price
+                    FROM pricing_items_history
+                    WHERE base_item_id = ? AND price_source != 'internal'
+                    AND price_date >= date('now', '-6 months')
+                """
+                
+                market_result = self.db.fetch_one(market_query, [item_id])
+                
+                if market_result and market_result[0]:
+                    item_data['market_price'] = market_result[0]
+                    
+                    # حساب الفرق بين السعر الحالي وسعر السوق
+                    item_data['price_difference'] = item_data['current_price'] - item_data['market_price']
+                    item_data['price_difference_percentage'] = (item_data['price_difference'] / item_data['market_price']) * 100
+                    
+                    # تحديد حالة السعر
+                    if abs(item_data['price_difference_percentage']) < 5:
+                        item_data['price_status'] = 'competitive'
+                        item_data['price_status_description'] = 'تنافسي'
+                    elif item_data['price_difference_percentage'] < 0:
+                        item_data['price_status'] = 'below_market'
+                        item_data['price_status_description'] = 'أقل من السوق'
+                    else:
+                        item_data['price_status'] = 'above_market'
+                        item_data['price_status_description'] = 'أعلى من السوق'
+                else:
+                    # إذا لم يتم العثور على سعر سوق، نستخدم متوسط الأسعار الداخلية
+                    internal_query = """
+                        SELECT AVG(price) as avg_price
+                        FROM pricing_items_history
+                        WHERE base_item_id = ?
+                        AND price_date >= date('now', '-6 months')
+                    """
+                    
+                    internal_result = self.db.fetch_one(internal_query, [item_id])
+                    
+                    if internal_result and internal_result[0]:
+                        item_data['market_price'] = internal_result[0]
+                        item_data['price_difference'] = item_data['current_price'] - item_data['market_price']
+                        item_data['price_difference_percentage'] = (item_data['price_difference'] / item_data['market_price']) * 100
+                        
+                        # تحديد حالة السعر
+                        if abs(item_data['price_difference_percentage']) < 5:
+                            item_data['price_status'] = 'competitive'
+                            item_data['price_status_description'] = 'تنافسي'
+                        elif item_data['price_difference_percentage'] < 0:
+                            item_data['price_status'] = 'below_average'
+                            item_data['price_status_description'] = 'أقل من المتوسط'
+                        else:
+                            item_data['price_status'] = 'above_average'
+                            item_data['price_status_description'] = 'أعلى من المتوسط'
+                    else:
+                        item_data['market_price'] = None
+                        item_data['price_difference'] = None
+                        item_data['price_difference_percentage'] = None
+                        item_data['price_status'] = 'unknown'
+                        item_data['price_status_description'] = 'غير معروف'
+                
+                comparison_data.append(item_data)
+            
+            if not comparison_data:
+                return {
+                    'status': 'error',
+                    'message': 'لم يتم العثور على أي بنود للمقارنة'
+                }
+            
+            # إنشاء رسم بياني للمقارنة
+            chart_path = self._create_market_comparison_chart(comparison_data)
+            
+            return {
+                'status': 'success',
+                'data': {
+                    'items': comparison_data,
+                    'chart_path': chart_path
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"خطأ في مقارنة الأسعار مع أسعار السوق: {str(e)}")
+            return {
+                'status': 'error',
+                'message': f'حدث خطأ أثناء مقارنة الأسعار مع أسعار السوق: {str(e)}'
+            }
+    
+    def _create_market_comparison_chart(self, comparison_data):
+        """إنشاء رسم بياني لمقارنة الأسعار مع أسعار السوق
+        
+        المعلمات:
+            comparison_data (list): بيانات المقارنة
+            
+        العائد:
+            str: مسار ملف الرسم البياني
+        """
+        try:
+            # تصفية البنود التي لها أسعار سوق
+            valid_items = [item for item in comparison_data if item.get('market_price') is not None]
+            
+            if not valid_items:
+                return None
+            
+            # إنشاء رسم بياني جديد
+            plt.figure(figsize=(12, 6))
+            
+            # إعداد البيانات للرسم
+            names = [f"{item['code']} - {item['name'][:20]}..." for item in valid_items]
+            current_prices = [item['current_price'] for item in valid_items]
+            market_prices = [item['market_price'] for item in valid_items]
+            
+            # إنشاء مواقع الأعمدة
+            x = np.arange(len(names))
+            width = 0.35
+            
+            # رسم الأعمدة
+            plt.bar(x - width/2, current_prices, width, label='السعر الحالي', color='skyblue')
+            plt.bar(x + width/2, market_prices, width, label='سعر السوق', color='lightgreen')
+            
+            # إضافة تسميات وعنوان
+            plt.xlabel('البنود')
+            plt.ylabel('السعر')
+            plt.title('مقارنة الأسعار الحالية مع أسعار السوق')
+            plt.xticks(x, names, rotation=45, ha='right')
+            plt.legend()
+            
+            # إضافة شبكة
+            plt.grid(True, linestyle='--', alpha=0.7, axis='y')
+            
+            # إضافة قيم الفروق النسبية
+            for i, item in enumerate(valid_items):
+                if 'price_difference_percentage' in item and item['price_difference_percentage'] is not None:
+                    percentage = item['price_difference_percentage']
+                    color = 'green' if percentage < 0 else 'red' if percentage > 0 else 'black'
+                    plt.annotate(f"{percentage:.1f}%", 
+                                xy=(x[i], max(current_prices[i], market_prices[i]) * 1.05),
+                                ha='center', va='bottom', color=color,
+                                bbox=dict(boxstyle="round,pad=0.3", fc="white", ec="gray", alpha=0.8))
+            
+            # ضبط التخطيط
+            plt.tight_layout()
+            
+            # حفظ الرسم البياني
+            chart_filename = f"market_comparison_{datetime.now().strftime('%Y%m%d%H%M%S')}.png"
+            chart_path = os.path.join(self.charts_dir, chart_filename)
+            plt.savefig(chart_path, dpi=100, bbox_inches='tight')
+            plt.close()
+            
+            return chart_path
+            
+        except Exception as e:
+            logger.error(f"خطأ في إنشاء رسم بياني لمقارنة الأسعار مع أسعار السوق: {str(e)}")
+            return None
+    
+    def analyze_cost_drivers(self, project_id):
+        """تحليل محركات التكلفة للمشروع
+        
+        المعلمات:
+            project_id (int): معرف المشروع
+            
+        العائد:
+            dict: قاموس يحتوي على نتائج تحليل محركات التكلفة
+        """
+        try:
+            # الحصول على بنود المشروع
+            query = """
+                SELECT 
+                    id, item_number, description, quantity, unit_price, total_price,
+                    (SELECT name FROM pricing_categories WHERE id = 
+                        (SELECT category_id FROM pricing_items_base WHERE id = base_item_id)
+                    ) as category_name
+                FROM 
+                    project_pricing_items
+                WHERE 
+                    project_id = ?
+            """
+            
+            results = self.db.fetch_all(query, [project_id])
+            
+            if not results:
+                return {
+                    'status': 'error',
+                    'message': 'لا توجد بنود للمشروع المحدد'
+                }
+            
+            # تحويل النتائج إلى إطار بيانات
+            df = pd.DataFrame(results, columns=[
+                'id', 'item_number', 'description', 'quantity', 'unit_price', 
+                'total_price', 'category_name'
+            ])
+            
+            # معالجة القيم المفقودة في عمود الفئة
+            df['category_name'] = df['category_name'].fillna('أخرى')
+            
+            # حساب إجمالي المشروع
+            project_total = df['total_price'].sum()
+            
+            # تحليل البنود حسب الفئة
+            category_analysis = df.groupby('category_name').agg({
+                'total_price': 'sum'
+            }).reset_index()
+            
+            # إضافة النسبة المئوية
+            category_analysis['percentage'] = (category_analysis['total_price'] / project_total) * 100
+            
+            # ترتيب الفئات حسب التكلفة
+            category_analysis = category_analysis.sort_values('total_price', ascending=False)
+            
+            # تحليل البنود الأعلى تكلفة
+            top_items = df.sort_values('total_price', ascending=False).head(10)
+            top_items['percentage'] = (top_items['total_price'] / project_total) * 100
+            
+            # حساب تركيز التكلفة (نسبة باريتو)
+            df_sorted = df.sort_values('total_price', ascending=False)
+            df_sorted['cumulative_cost'] = df_sorted['total_price'].cumsum()
+            df_sorted['cumulative_percentage'] = (df_sorted['cumulative_cost'] / project_total) * 100
+            
+            # تحديد عدد البنود التي تشكل 80% من التكلفة
+            items_80_percent = len(df_sorted[df_sorted['cumulative_percentage'] <= 80])
+            if items_80_percent == 0:
+                items_80_percent = 1
+            
+            pareto_ratio = items_80_percent / len(df)
+            
+            # إنشاء رسوم بيانية
+            category_chart_path = self._create_category_chart(category_analysis)
+            top_items_chart_path = self._create_top_items_chart(top_items)
+            pareto_chart_path = self._create_pareto_chart(df_sorted)
+            
+            return {
+                'status': 'success',
+                'data': {
+                    'project_id': project_id,
+                    'project_total': project_total,
+                    'category_analysis': category_analysis.to_dict('records'),
+                    'top_items': top_items.to_dict('records'),
+                    'pareto_ratio': pareto_ratio,
+                    'items_80_percent': items_80_percent,
+                    'total_items': len(df),
+                    'category_chart_path': category_chart_path,
+                    'top_items_chart_path': top_items_chart_path,
+                    'pareto_chart_path': pareto_chart_path
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"خطأ في تحليل محركات التكلفة: {str(e)}")
+            return {
+                'status': 'error',
+                'message': f'حدث خطأ أثناء تحليل محركات التكلفة: {str(e)}'
+            }
+    
+    def _create_category_chart(self, category_analysis):
+        """إنشاء رسم بياني للتكاليف حسب الفئة
+        
+        المعلمات:
+            category_analysis (pandas.DataFrame): تحليل الفئات
+            
+        العائد:
+            str: مسار ملف الرسم البياني
+        """
+        try:
+            # إنشاء رسم بياني جديد
+            plt.figure(figsize=(10, 6))
+            
+            # رسم مخطط دائري
+            plt.pie(
+                category_analysis['total_price'],
+                labels=category_analysis['category_name'],
+                autopct='%1.1f%%',
+                startangle=90,
+                shadow=False,
+                wedgeprops={'edgecolor': 'white', 'linewidth': 1}
+            )
+            
+            # إضافة عنوان
+            plt.title('توزيع التكاليف حسب الفئة')
+            
+            # جعل الرسم البياني دائريًا
+            plt.axis('equal')
+            
+            # ضبط التخطيط
+            plt.tight_layout()
+            
+            # حفظ الرسم البياني
+            chart_filename = f"cost_category_{datetime.now().strftime('%Y%m%d%H%M%S')}.png"
+            chart_path = os.path.join(self.charts_dir, chart_filename)
+            plt.savefig(chart_path, dpi=100, bbox_inches='tight')
+            plt.close()
+            
+            return chart_path
+            
+        except Exception as e:
+            logger.error(f"خطأ في إنشاء رسم بياني للتكاليف حسب الفئة: {str(e)}")
+            return None
+    
+    def _create_top_items_chart(self, top_items):
+        """إنشاء رسم بياني للبنود الأعلى تكلفة
+        
+        المعلمات:
+            top_items (pandas.DataFrame): البنود الأعلى تكلفة
+            
+        العائد:
+            str: مسار ملف الرسم البياني
+        """
+        try:
+            # إنشاء رسم بياني جديد
+            plt.figure(figsize=(12, 6))
+            
+            # إعداد البيانات للرسم
+            items = [f"{row['item_number']} - {row['description'][:20]}..." for _, row in top_items.iterrows()]
+            costs = top_items['total_price'].tolist()
+            
+            # رسم الأعمدة
+            bars = plt.barh(items, costs, color='skyblue', edgecolor='navy')
+            
+            # إضافة القيم على الأعمدة
+            for i, bar in enumerate(bars):
+                width = bar.get_width()
+                plt.text(width * 1.01, bar.get_y() + bar.get_height()/2,
+                        f'{width:,.0f} ({top_items["percentage"].iloc[i]:.1f}%)',
+                        va='center')
+            
+            # إضافة عنوان ومحاور
+            plt.title('البنود الأعلى تكلفة')
+            plt.xlabel('التكلفة')
+            plt.ylabel('البنود')
+            
+            # إضافة شبكة
+            plt.grid(True, linestyle='--', alpha=0.7, axis='x')
+            
+            # ضبط التخطيط
+            plt.tight_layout()
+            
+            # حفظ الرسم البياني
+            chart_filename = f"top_cost_items_{datetime.now().strftime('%Y%m%d%H%M%S')}.png"
+            chart_path = os.path.join(self.charts_dir, chart_filename)
+            plt.savefig(chart_path, dpi=100, bbox_inches='tight')
+            plt.close()
+            
+            return chart_path
+            
+        except Exception as e:
+            logger.error(f"خطأ في إنشاء رسم بياني للبنود الأعلى تكلفة: {str(e)}")
+            return None
+    
+    def _create_pareto_chart(self, df_sorted):
+        """إنشاء رسم بياني لتحليل باريتو
+        
+        المعلمات:
+            df_sorted (pandas.DataFrame): إطار البيانات المرتب
+            
+        العائد:
+            str: مسار ملف الرسم البياني
+        """
+        try:
+            # إنشاء رسم بياني جديد
+            fig, ax1 = plt.subplots(figsize=(12, 6))
+            
+            # إعداد البيانات للرسم
+            x = range(1, len(df_sorted) + 1)
+            y1 = df_sorted['total_price'].tolist()
+            y2 = df_sorted['cumulative_percentage'].tolist()
+            
+            # رسم الأعمدة (التكلفة)
+            ax1.bar(x, y1, color='skyblue', alpha=0.7)
+            ax1.set_xlabel('عدد البنود')
+            ax1.set_ylabel('التكلفة', color='navy')
+            ax1.tick_params(axis='y', labelcolor='navy')
+            
+            # إنشاء محور ثانوي
+            ax2 = ax1.twinx()
+            
+            # رسم الخط (النسبة التراكمية)
+            ax2.plot(x, y2, 'r-', linewidth=2, marker='o', markersize=4)
+            ax2.set_ylabel('النسبة التراكمية (%)', color='red')
+            ax2.tick_params(axis='y', labelcolor='red')
+            
+            # إضافة خط 80%
+            ax2.axhline(y=80, color='green', linestyle='--', alpha=0.7)
+            
+            # إضافة عنوان
+            plt.title('تحليل باريتو للتكاليف')
+            
+            # إضافة شبكة
+            ax1.grid(True, linestyle='--', alpha=0.7)
+            
+            # ضبط التخطيط
+            fig.tight_layout()
+            
+            # حفظ الرسم البياني
+            chart_filename = f"pareto_analysis_{datetime.now().strftime('%Y%m%d%H%M%S')}.png"
+            chart_path = os.path.join(self.charts_dir, chart_filename)
+            plt.savefig(chart_path, dpi=100, bbox_inches='tight')
+            plt.close()
+            
+            return chart_path
+            
+        except Exception as e:
+            logger.error(f"خطأ في إنشاء رسم بياني لتحليل باريتو: {str(e)}")
+            return None
+    
+    def generate_price_analysis_charts(self, analysis_type, params):
+        """إنشاء رسوم بيانية لتحليل الأسعار
+        
+        المعلمات:
+            analysis_type (str): نوع التحليل
+            params (dict): معلمات التحليل
+            
+        العائد:
+            dict: قاموس يحتوي على مسارات الرسوم البيانية
+        """
+        try:
+            if analysis_type == 'trend':
+                # تحليل اتجاه السعر
+                if 'item_id' not in params:
+                    return {
+                        'status': 'error',
+                        'message': 'لم يتم تحديد معرف البند'
+                    }
+                
+                result = self.analyze_price_trends(
+                    params['item_id'],
+                    params.get('start_date'),
+                    params.get('end_date')
+                )
+                
+                if result['status'] == 'success':
+                    return {
+                        'status': 'success',
+                        'charts': [result['data']['chart_path']]
+                    }
+                else:
+                    return result
+                
+            elif analysis_type == 'comparison':
+                # مقارنة الأسعار
+                if 'items' not in params:
+                    return {
+                        'status': 'error',
+                        'message': 'لم يتم تحديد البنود للمقارنة'
+                    }
+                
+                result = self.compare_prices(
+                    params['items'],
+                    params.get('date')
+                )
+                
+                if result['status'] == 'success':
+                    return {
+                        'status': 'success',
+                        'charts': [result['data']['chart_path']]
+                    }
+                else:
+                    return result
+                
+            elif analysis_type == 'volatility':
+                # تحليل تقلب الأسعار
+                if 'item_id' not in params:
+                    return {
+                        'status': 'error',
+                        'message': 'لم يتم تحديد معرف البند'
+                    }
+                
+                result = self.calculate_price_volatility(
+                    params['item_id'],
+                    params.get('period', '1y')
+                )
+                
+                if result['status'] == 'success':
+                    return {
+                        'status': 'success',
+                        'charts': [result['data']['chart_path']]
+                    }
+                else:
+                    return result
+                
+            elif analysis_type == 'sensitivity':
+                # تحليل الحساسية
+                if 'project_id' not in params or 'variable_items' not in params:
+                    return {
+                        'status': 'error',
+                        'message': 'لم يتم تحديد معرف المشروع أو البنود المتغيرة'
+                    }
+                
+                result = self.perform_sensitivity_analysis(
+                    params['project_id'],
+                    params['variable_items'],
+                    params.get('ranges', {})
+                )
+                
+                if result['status'] == 'success':
+                    return {
+                        'status': 'success',
+                        'charts': [result['data']['chart_path']]
+                    }
+                else:
+                    return result
+                
+            elif analysis_type == 'correlation':
+                # تحليل الارتباطات
+                if 'items' not in params:
+                    return {
+                        'status': 'error',
+                        'message': 'لم يتم تحديد البنود للتحليل'
+                    }
+                
+                result = self.analyze_price_correlations(params['items'])
+                
+                if result['status'] == 'success':
+                    return {
+                        'status': 'success',
+                        'charts': [result['data']['chart_path'], result['data']['trends_chart_path']]
+                    }
+                else:
+                    return result
+                
+            elif analysis_type == 'market_comparison':
+                # مقارنة مع أسعار السوق
+                if 'items' not in params:
+                    return {
+                        'status': 'error',
+                        'message': 'لم يتم تحديد البنود للمقارنة'
+                    }
+                
+                result = self.compare_with_market_prices(params['items'])
+                
+                if result['status'] == 'success':
+                    return {
+                        'status': 'success',
+                        'charts': [result['data']['chart_path']]
+                    }
+                else:
+                    return result
+                
+            elif analysis_type == 'cost_drivers':
+                # تحليل محركات التكلفة
+                if 'project_id' not in params:
+                    return {
+                        'status': 'error',
+                        'message': 'لم يتم تحديد معرف المشروع'
+                    }
+                
+                result = self.analyze_cost_drivers(params['project_id'])
+                
+                if result['status'] == 'success':
+                    return {
+                        'status': 'success',
+                        'charts': [
+                            result['data']['category_chart_path'],
+                            result['data']['top_items_chart_path'],
+                            result['data']['pareto_chart_path']
+                        ]
+                    }
+                else:
+                    return result
+                
+            else:
+                return {
+                    'status': 'error',
+                    'message': f'نوع التحليل غير معروف: {analysis_type}'
+                }
+                
+        except Exception as e:
+            logger.error(f"خطأ في إنشاء رسوم بيانية لتحليل الأسعار: {str(e)}")
+            return {
+                'status': 'error',
+                'message': f'حدث خطأ أثناء إنشاء رسوم بيانية لتحليل الأسعار: {str(e)}'
+            }

modules/pricing/pricing_app.py

@@ -0,0 +1,1760 @@
+"""
+وحدة التسعير - التطبيق الرئيسي
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime
+import time
+import io
+import os
+import json
+import base64
+from pathlib import Path
+
+class PricingApp:
+    """وحدة التسعير"""
+    
+    def __init__(self):
+        """تهيئة وحدة التسعير"""
+        
+        # تهيئة حالة الجلسة
+        if 'bill_of_quantities' not in st.session_state:
+            st.session_state.bill_of_quantities = [
+                {
+                    'id': 1,
+                    'code': 'A-001',
+                    'description': 'أعمال الحفر والردم',
+                    'unit': 'م3',
+                    'quantity': 1500,
+                    'unit_price': 45,
+                    'total_price': 67500,
+                    'category': 'أعمال ترابية'
+                },
+                {
+                    'id': 2,
+                    'code': 'A-002',
+                    'description': 'توريد وصب خرسانة عادية',
+                    'unit': 'م3',
+                    'quantity': 250,
+                    'unit_price': 350,
+                    'total_price': 87500,
+                    'category': 'أعمال خرسانية'
+                },
+                {
+                    'id': 3,
+                    'code': 'A-003',
+                    'description': 'توريد وصب خرسانة مسلحة للأساسات',
+                    'unit': 'م3',
+                    'quantity': 180,
+                    'unit_price': 450,
+                    'total_price': 81000,
+                    'category': 'أعمال خرسانية'
+                },
+                {
+                    'id': 4,
+                    'code': 'B-001',
+                    'description': 'توريد وتركيب حديد تسليح',
+                    'unit': 'طن',
+                    'quantity': 15,
+                    'unit_price': 3500,
+                    'total_price': 52500,
+                    'category': 'أعمال حديد'
+                },
+                {
+                    'id': 5,
+                    'code': 'C-001',
+                    'description': 'توريد وبناء طابوق',
+                    'unit': 'م2',
+                    'quantity': 450,
+                    'unit_price': 120,
+                    'total_price': 54000,
+                    'category': 'أعمال بناء'
+                }
+            ]
+        
+        if 'cost_analysis' not in st.session_state:
+            st.session_state.cost_analysis = [
+                {
+                    'id': 1,
+                    'category': 'تكاليف مباشرة',
+                    'subcategory': 'مواد',
+                    'description': 'خرسانة',
+                    'amount': 168500,
+                    'percentage': 25.2
+                },
+                {
+                    'id': 2,
+                    'category': 'تكاليف مباشرة',
+                    'subcategory': 'مواد',
+                    'description': 'حديد تسليح',
+                    'amount': 52500,
+                    'percentage': 7.8
+                },
+                {
+                    'id': 3,
+                    'category': 'تكاليف مباشرة',
+                    'subcategory': 'مواد',
+                    'description': 'طابوق',
+                    'amount': 54000,
+                    'percentage': 8.1
+                },
+                {
+                    'id': 4,
+                    'category': 'تكاليف مباشرة',
+                    'subcategory': 'عمالة',
+                    'description': 'عمالة تنفيذ',
+                    'amount': 120000,
+                    'percentage': 17.9
+                },
+                {
+                    'id': 5,
+                    'category': 'تكاليف مباشرة',
+                    'subcategory': 'معدات',
+                    'description': 'معدات إنشائية',
+                    'amount': 85000,
+                    'percentage': 12.7
+                },
+                {
+                    'id': 6,
+                    'category': 'تكاليف غير مباشرة',
+                    'subcategory': 'إدارة',
+                    'description': 'إدارة المشروع',
+                    'amount': 45000,
+                    'percentage': 6.7
+                },
+                {
+                    'id': 7,
+                    'category': 'تكاليف غير مباشرة',
+                    'subcategory': 'إدارة',
+                    'description': 'إشراف هندسي',
+                    'amount': 35000,
+                    'percentage': 5.2
+                },
+                {
+                    'id': 8,
+                    'category': 'تكاليف غير مباشرة',
+                    'subcategory': 'عامة',
+                    'description': 'تأمينات وضمانات',
+                    'amount': 25000,
+                    'percentage': 3.7
+                },
+                {
+                    'id': 9,
+                    'category': 'تكاليف غير مباشرة',
+                    'subcategory': 'عامة',
+                    'description': 'مصاريف إدارية',
+                    'amount': 30000,
+                    'percentage': 4.5
+                },
+                {
+                    'id': 10,
+                    'category': 'أرباح',
+                    'subcategory': 'أرباح',
+                    'description': 'هامش الربح',
+                    'amount': 55000,
+                    'percentage': 8.2
+                }
+            ]
+        
+        if 'price_scenarios' not in st.session_state:
+            st.session_state.price_scenarios = [
+                {
+                    'id': 1,
+                    'name': 'السيناريو الأساسي',
+                    'description': 'التسعير الأساسي مع هامش ربح 8%',
+                    'total_cost': 615000,
+                    'profit_margin': 8.2,
+                    'total_price': 670000,
+                    'is_active': True
+                },
+                {
+                    'id': 2,
+                    'name': 'سيناريو تنافسي',
+                    'description': 'تخفيض هامش الربح للمنافسة',
+                    'total_cost': 615000,
+                    'profit_margin': 5.0,
+                    'total_price': 650000,
+                    'is_active': False
+                },
+                {
+                    'id': 3,
+                    'name': 'سيناريو مرتفع',
+                    'description': 'زيادة هامش الربح للمشاريع ذات المخاطر العالية',
+                    'total_cost': 615000,
+                    'profit_margin': 12.0,
+                    'total_price': 700000,
+                    'is_active': False
+                }
+            ]
+    
+    def render(self):
+        """عرض واجهة وحدة التسعير"""
+        
+        st.markdown("<h1 class='module-title'>وحدة التسعير</h1>", unsafe_allow_html=True)
+        
+        tabs = st.tabs([
+            "لوحة التحكم", 
+            "جدول الكميات",
+            "تحليل التكاليف",
+            "سيناريوهات التسعير",
+            "المقارنة التنافسية",
+            "التقارير"
+        ])
+        
+        with tabs[0]:
+            self._render_dashboard_tab()
+        
+        with tabs[1]:
+            self._render_bill_of_quantities_tab()
+        
+        with tabs[2]:
+            self._render_cost_analysis_tab()
+        
+        with tabs[3]:
+            self._render_pricing_scenarios_tab()
+        
+        with tabs[4]:
+            self._render_competitive_analysis_tab()
+        
+        with tabs[5]:
+            self._render_reports_tab()
+    
+    def _render_dashboard_tab(self):
+        """عرض تبويب لوحة التحكم"""
+        
+        st.markdown("### لوحة تحكم التسعير")
+        
+        # عرض ملخص التسعير
+        col1, col2, col3, col4 = st.columns(4)
+        
+        # حساب إجمالي التكاليف
+        total_direct_cost = sum(item['amount'] for item in st.session_state.cost_analysis if item['category'] == 'تكاليف مباشرة')
+        total_indirect_cost = sum(item['amount'] for item in st.session_state.cost_analysis if item['category'] == 'تكاليف غير مباشرة')
+        total_profit = sum(item['amount'] for item in st.session_state.cost_analysis if item['category'] == 'أرباح')
+        total_cost = total_direct_cost + total_indirect_cost
+        total_price = total_cost + total_profit
+        
+        with col1:
+            st.metric("إجمالي التكاليف المباشرة", f"{total_direct_cost:,.0f} ريال")
+        
+        with col2:
+            st.metric("إجمالي التكاليف غير المباشرة", f"{total_indirect_cost:,.0f} ريال")
+        
+        with col3:
+            st.metric("إجمالي التكاليف", f"{total_cost:,.0f} ريال")
+        
+        with col4:
+            st.metric("السعر الإجمالي", f"{total_price:,.0f} ريال")
+        
+        # عرض توزيع التكاليف
+        st.markdown("### توزيع التكاليف")
+        
+        # تجميع البيانات حسب الفئة
+        cost_categories = {}
+        
+        for item in st.session_state.cost_analysis:
+            category = item['category']
+            if category in cost_categories:
+                cost_categories[category] += item['amount']
+            else:
+                cost_categories[category] = item['amount']
+        
+        # إنشاء DataFrame للرسم البياني
+        cost_df = pd.DataFrame({
+            'الفئة': list(cost_categories.keys()),
+            'المبلغ': list(cost_categories.values())
+        })
+        
+        # إنشاء رسم بياني دائري
+        fig = px.pie(
+            cost_df,
+            values='المبلغ',
+            names='الفئة',
+            title='توزيع التكاليف حسب الفئة',
+            color_discrete_sequence=px.colors.qualitative.Set3
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع التكاليف المباشرة
+        st.markdown("### توزيع التكاليف المباشرة")
+        
+        # تجميع البيانات حسب الفئة الفرعية للتكاليف المباشرة
+        direct_cost_subcategories = {}
+        
+        for item in st.session_state.cost_analysis:
+            if item['category'] == 'تكاليف مباشرة':
+                subcategory = item['subcategory']
+                if subcategory in direct_cost_subcategories:
+                    direct_cost_subcategories[subcategory] += item['amount']
+                else:
+                    direct_cost_subcategories[subcategory] = item['amount']
+        
+        # إنشاء DataFrame للرسم البياني
+        direct_cost_df = pd.DataFrame({
+            'الفئة الفرعية': list(direct_cost_subcategories.keys()),
+            'المبلغ': list(direct_cost_subcategories.values())
+        })
+        
+        # إنشاء رسم بياني شريطي
+        fig = px.bar(
+            direct_cost_df,
+            x='الفئة الفرعية',
+            y='المبلغ',
+            title='توزيع التكاليف المباشرة',
+            color='الفئة الفرعية',
+            text_auto='.2s'
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض مقارنة سيناريوهات التسعير
+        st.markdown("### مقارنة سيناريوهات التسعير")
+        
+        # إنشاء DataFrame للرسم البياني
+        scenarios_df = pd.DataFrame({
+            'السيناريو': [item['name'] for item in st.session_state.price_scenarios],
+            'التكلفة الإجمالية': [item['total_cost'] for item in st.session_state.price_scenarios],
+            'هامش الربح (%)': [item['profit_margin'] for item in st.session_state.price_scenarios],
+            'السعر الإجمالي': [item['total_price'] for item in st.session_state.price_scenarios]
+        })
+        
+        # إنشاء رسم بياني شريطي مزدوج
+        fig = go.Figure()
+        
+        # إضافة شريط للتكلفة الإجمالية
+        fig.add_trace(go.Bar(
+            x=scenarios_df['السيناريو'],
+            y=scenarios_df['التكلفة الإجمالية'],
+            name='التكلفة الإجمالية',
+            marker_color='indianred'
+        ))
+        
+        # إضافة شريط للسعر الإجمالي
+        fig.add_trace(go.Bar(
+            x=scenarios_df['السيناريو'],
+            y=scenarios_df['السعر الإجمالي'],
+            name='السعر الإجمالي',
+            marker_color='lightsalmon'
+        ))
+        
+        # إضافة خط لهامش الربح
+        fig.add_trace(go.Scatter(
+            x=scenarios_df['السيناريو'],
+            y=scenarios_df['هامش الربح (%)'] * 10000,  # تكبير القيم لتظهر على الرسم البياني
+            name='هامش الربح (%)',
+            yaxis='y2',
+            line=dict(color='royalblue', width=4)
+        ))
+        
+        # تعديل تخطيط الرسم البياني
+        fig.update_layout(
+            title='مقارنة سيناريوهات التسعير',
+            xaxis_title='السيناريو',
+            yaxis_title='المبلغ (ريال)',
+            yaxis2=dict(
+                title='هامش الربح (%)',
+                titlefont=dict(color='royalblue'),
+                tickfont=dict(color='royalblue'),
+                overlaying='y',
+                side='right',
+                range=[0, 20]
+            ),
+            barmode='group',
+            legend=dict(
+                x=0,
+                y=1.2,
+                orientation='h'
+            )
+        )
+        
+        # تعديل النص على الأشرطة
+        fig.update_traces(
+            texttemplate='%{y:,.0f}',
+            textposition='outside'
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض مؤشرات الأداء الرئيسية
+        st.markdown("### مؤشرات الأداء الرئيسية")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            # حساب نسبة التكاليف المباشرة من إجمالي التكاليف
+            direct_cost_percentage = (total_direct_cost / total_cost) * 100
+            st.metric("نسبة التكاليف المباشرة", f"{direct_cost_percentage:.1f}%")
+        
+        with col2:
+            # حساب نسبة التكاليف غير المباشرة من إجمالي التكاليف
+            indirect_cost_percentage = (total_indirect_cost / total_cost) * 100
+            st.metric("نسبة التكاليف غير المباشرة", f"{indirect_cost_percentage:.1f}%")
+        
+        with col3:
+            # حساب نسبة هامش الربح من السعر الإجمالي
+            profit_margin = (total_profit / total_price) * 100
+            st.metric("هامش الربح", f"{profit_margin:.1f}%")
+    
+    def _render_bill_of_quantities_tab(self):
+        """عرض تبويب جدول الكميات"""
+        
+        st.markdown("### جدول الكميات")
+        
+        # عرض جدول الكميات الحالي
+        st.markdown("#### قائمة البنود")
+        
+        # تحويل قائمة البنود إلى DataFrame
+        boq_df = pd.DataFrame(st.session_state.bill_of_quantities)
+        
+        # عرض البنود كجدول قابل للتعديل
+        edited_df = st.data_editor(
+            boq_df,
+            column_config={
+                "id": st.column_config.NumberColumn("الرقم", disabled=True),
+                "code": st.column_config.TextColumn("الكود"),
+                "description": st.column_config.TextColumn("الوصف"),
+                "unit": st.column_config.SelectboxColumn(
+                    "الوحدة",
+                    options=["م3", "م2", "طن", "كجم", "عدد", "لتر", "متر"]
+                ),
+                "quantity": st.column_config.NumberColumn("الكمية", min_value=0),
+                "unit_price": st.column_config.NumberColumn("سعر الوحدة (ريال)", min_value=0, format="%.2f"),
+                "total_price": st.column_config.NumberColumn("السعر الإجمالي (ريال)", min_value=0, format="%.2f", disabled=True),
+                "category": st.column_config.SelectboxColumn(
+                    "الفئة",
+                    options=["أعمال ترابية", "أعمال خرسانية", "أعمال حديد", "أعمال بناء", "أعمال تشطيب", "أعمال كهربائية", "أعمال ميكانيكية", "أعمال صحية", "أخرى"]
+                )
+            },
+            use_container_width=True,
+            hide_index=True,
+            num_rows="dynamic"
+        )
+        
+        # تحديث السعر الإجمالي لكل بند
+        for i, row in edited_df.iterrows():
+            edited_df.at[i, 'total_price'] = row['quantity'] * row['unit_price']
+        
+        # تحديث قائمة البنود
+        if not edited_df.equals(boq_df):
+            st.session_state.bill_of_quantities = edited_df.to_dict('records')
+            st.success("تم تحديث جدول الكميات بنجاح!")
+        
+        # عرض إجمالي جدول الكميات
+        total_boq = sum(item['total_price'] for item in st.session_state.bill_of_quantities)
+        st.metric("إجمالي جدول الكميات", f"{total_boq:,.2f} ريال")
+        
+        # إضافة بند جديد
+        st.markdown("#### إضافة بند جديد")
+        
+        with st.form(key="add_boq_item_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                new_code = st.text_input("الكود", key="new_boq_code")
+                new_description = st.text_area("الوصف", key="new_boq_description")
+                new_category = st.selectbox(
+                    "الفئة",
+                    ["أعمال ترابية", "أعمال خرسانية", "أعمال حديد", "أعمال بناء", "أعمال تشطيب", "أعمال كهربائية", "أعمال ميكانيكية", "أعمال صحية", "أخرى"],
+                    key="new_boq_category"
+                )
+            
+            with col2:
+                new_unit = st.selectbox(
+                    "الوحدة",
+                    ["م3", "م2", "طن", "كجم", "عدد", "لتر", "متر"],
+                    key="new_boq_unit"
+                )
+                new_quantity = st.number_input("الكمية", min_value=0.0, key="new_boq_quantity")
+                new_unit_price = st.number_input("سعر الوحدة (ريال)", min_value=0.0, key="new_boq_unit_price")
+            
+            submit_button = st.form_submit_button("إضافة بند")
+        
+        if submit_button:
+            if new_code and new_description:
+                # إنشاء معرف جديد
+                new_id = max([item['id'] for item in st.session_state.bill_of_quantities], default=0) + 1
+                
+                # حساب السعر الإجمالي
+                new_total_price = new_quantity * new_unit_price
+                
+                # إضافة البند الجديد
+                st.session_state.bill_of_quantities.append({
+                    'id': new_id,
+                    'code': new_code,
+                    'description': new_description,
+                    'unit': new_unit,
+                    'quantity': new_quantity,
+                    'unit_price': new_unit_price,
+                    'total_price': new_total_price,
+                    'category': new_category
+                })
+                
+                st.success(f"تمت إضافة البند '{new_code}' بنجاح!")
+                st.rerun()
+            else:
+                st.error("يرجى إدخال الكود والوصف.")
+        
+        # تحليل جدول الكميات
+        st.markdown("#### تحليل جدول الكميات")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # توزيع البنود حسب الفئة
+            category_totals = {}
+            
+            for item in st.session_state.bill_of_quantities:
+                category = item['category']
+                if category in category_totals:
+                    category_totals[category] += item['total_price']
+                else:
+                    category_totals[category] = item['total_price']
+            
+            category_df = pd.DataFrame({
+                'الفئة': list(category_totals.keys()),
+                'المبلغ': list(category_totals.values())
+            })
+            
+            fig = px.pie(
+                category_df,
+                values='المبلغ',
+                names='الفئة',
+                title='توزيع جدول الكميات حسب الفئة'
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            # ترتيب البنود حسب القيمة
+            top_items = sorted(st.session_state.bill_of_quantities, key=lambda x: x['total_price'], reverse=True)[:5]
+            
+            top_items_df = pd.DataFrame({
+                'البند': [item['code'] + ' - ' + item['description'][:20] + '...' for item in top_items],
+                'القيمة': [item['total_price'] for item in top_items]
+            })
+            
+            fig = px.bar(
+                top_items_df,
+                x='البند',
+                y='القيمة',
+                title='أعلى 5 بنود من حيث القيمة',
+                color='القيمة',
+                text_auto='.2s'
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # استيراد وتصدير جدول الكميات
+        st.markdown("#### استيراد وتصدير جدول الكميات")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if st.button("تصدير جدول الكميات إلى Excel", key="export_boq_button"):
+                # محاكاة تصدير البيانات
+                st.success("تم تصدير جدول الكميات إلى Excel بنجاح!")
+        
+        with col2:
+            uploaded_file = st.file_uploader("استيراد جدول الكميات من Excel", type=["xlsx"], key="import_boq_file")
+            
+            if uploaded_file is not None:
+                if st.button("استيراد البيانات", key="import_boq_button"):
+                    # محاكاة استيراد البيانات
+                    st.success("تم استيراد جدول الكميات بنجاح!")
+    
+    def _render_cost_analysis_tab(self):
+        """عرض تبويب تحليل التكاليف"""
+        
+        st.markdown("### تحليل التكاليف")
+        
+        # عرض تحليل التكاليف الحالي
+        st.markdown("#### قائمة التكاليف")
+        
+        # تحويل قائمة التكاليف إلى DataFrame
+        cost_df = pd.DataFrame(st.session_state.cost_analysis)
+        
+        # عرض التكاليف كجدول قابل للتعديل
+        edited_df = st.data_editor(
+            cost_df,
+            column_config={
+                "id": st.column_config.NumberColumn("الرقم", disabled=True),
+                "category": st.column_config.SelectboxColumn(
+                    "الفئة",
+                    options=["تكاليف مباشرة", "تكاليف غير مباشرة", "أرباح"]
+                ),
+                "subcategory": st.column_config.TextColumn("الفئة الفرعية"),
+                "description": st.column_config.TextColumn("الوصف"),
+                "amount": st.column_config.NumberColumn("المبلغ (ريال)", min_value=0, format="%.2f"),
+                "percentage": st.column_config.NumberColumn("النسبة (%)", min_value=0, format="%.1f", disabled=True)
+            },
+            use_container_width=True,
+            hide_index=True,
+            num_rows="dynamic"
+        )
+        
+        # حساب إجمالي التكاليف
+        total_amount = sum(item['amount'] for item in st.session_state.cost_analysis)
+        
+        # تحديث النسبة المئوية لكل بند
+        for i, row in edited_df.iterrows():
+            edited_df.at[i, 'percentage'] = (row['amount'] / total_amount) * 100
+        
+        # تحديث قائمة التكاليف
+        if not edited_df.equals(cost_df):
+            st.session_state.cost_analysis = edited_df.to_dict('records')
+            st.success("تم تحديث تحليل التكاليف بنجاح!")
+        
+        # عرض إجمالي التكاليف
+        st.metric("إجمالي التكاليف", f"{total_amount:,.2f} ريال")
+        
+        # إضافة تكلفة جديدة
+        st.markdown("#### إضافة تكلفة جديدة")
+        
+        with st.form(key="add_cost_item_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                new_category = st.selectbox(
+                    "الفئة",
+                    ["تكاليف مباشرة", "تكاليف غير مباشرة", "أرباح"],
+                    key="new_cost_category"
+                )
+                new_subcategory = st.text_input("الفئة الفرعية", key="new_cost_subcategory")
+            
+            with col2:
+                new_description = st.text_input("الوصف", key="new_cost_description")
+                new_amount = st.number_input("المبلغ (ريال)", min_value=0.0, key="new_cost_amount")
+            
+            submit_button = st.form_submit_button("إضافة تكلفة")
+        
+        if submit_button:
+            if new_description and new_subcategory:
+                # إنشاء معرف جديد
+                new_id = max([item['id'] for item in st.session_state.cost_analysis], default=0) + 1
+                
+                # حساب النسبة المئوية
+                new_percentage = (new_amount / (total_amount + new_amount)) * 100
+                
+                # إضافة التكلفة الجديدة
+                st.session_state.cost_analysis.append({
+                    'id': new_id,
+                    'category': new_category,
+                    'subcategory': new_subcategory,
+                    'description': new_description,
+                    'amount': new_amount,
+                    'percentage': new_percentage
+                })
+                
+                # إعادة حساب النسب المئوية لجميع البنود
+                new_total = total_amount + new_amount
+                for item in st.session_state.cost_analysis:
+                    item['percentage'] = (item['amount'] / new_total) * 100
+                
+                st.success(f"تمت إضافة التكلفة '{new_description}' بنجاح!")
+                st.rerun()
+            else:
+                st.error("يرجى إدخال الفئة الفرعية والوصف.")
+        
+        # تحليل التكاليف
+        st.markdown("#### تحليل التكاليف")
+        
+        # تحليل التكاليف حسب الفئة
+        st.markdown("##### توزيع التكاليف حسب الفئة")
+        
+        # تجميع البيانات حسب الفئة
+        category_totals = {}
+        
+        for item in st.session_state.cost_analysis:
+            category = item['category']
+            if category in category_totals:
+                category_totals[category] += item['amount']
+            else:
+                category_totals[category] = item['amount']
+        
+        category_df = pd.DataFrame({
+            'الفئة': list(category_totals.keys()),
+            'المبلغ': list(category_totals.values())
+        })
+        
+        fig = px.pie(
+            category_df,
+            values='المبلغ',
+            names='الفئة',
+            title='توزيع التكاليف حسب الفئة',
+            color_discrete_sequence=px.colors.qualitative.Set3
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # تحليل التكاليف المباشرة
+        st.markdown("##### تحليل التكاليف المباشرة")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # تجميع البيانات حسب الفئة الفرعية للتكاليف المباشرة
+            direct_subcategory_totals = {}
+            
+            for item in st.session_state.cost_analysis:
+                if item['category'] == 'تكاليف مباشرة':
+                    subcategory = item['subcategory']
+                    if subcategory in direct_subcategory_totals:
+                        direct_subcategory_totals[subcategory] += item['amount']
+                    else:
+                        direct_subcategory_totals[subcategory] = item['amount']
+            
+            direct_subcategory_df = pd.DataFrame({
+                'الفئة الفرعية': list(direct_subcategory_totals.keys()),
+                'المبلغ': list(direct_subcategory_totals.values())
+            })
+            
+            fig = px.pie(
+                direct_subcategory_df,
+                values='المبلغ',
+                names='الفئة الفرعية',
+                title='توزيع التكاليف المباشرة حسب الفئة الفرعية'
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            # تجميع البيانات حسب الوصف للتكاليف المباشرة
+            direct_description_totals = {}
+            
+            for item in st.session_state.cost_analysis:
+                if item['category'] == 'تكاليف مباشرة':
+                    description = item['description']
+                    if description in direct_description_totals:
+                        direct_description_totals[description] += item['amount']
+                    else:
+                        direct_description_totals[description] = item['amount']
+            
+            direct_description_df = pd.DataFrame({
+                'الوصف': list(direct_description_totals.keys()),
+                'المبلغ': list(direct_description_totals.values())
+            })
+            
+            # ترتيب البيانات تنازلياً حسب المبلغ
+            direct_description_df = direct_description_df.sort_values(by='المبلغ', ascending=False)
+            
+            fig = px.bar(
+                direct_description_df,
+                x='الوصف',
+                y='المبلغ',
+                title='توزيع التكاليف المباشرة حسب البند',
+                color='المبلغ',
+                text_auto='.2s'
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # تحليل التكاليف غير المباشرة
+        st.markdown("##### تحليل التكاليف غير المباشرة")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # تجميع البيانات حسب الفئة الفرعية للتكاليف غير المباشرة
+            indirect_subcategory_totals = {}
+            
+            for item in st.session_state.cost_analysis:
+                if item['category'] == 'تكاليف غير مباشرة':
+                    subcategory = item['subcategory']
+                    if subcategory in indirect_subcategory_totals:
+                        indirect_subcategory_totals[subcategory] += item['amount']
+                    else:
+                        indirect_subcategory_totals[subcategory] = item['amount']
+            
+            indirect_subcategory_df = pd.DataFrame({
+                'الفئة الفرعية': list(indirect_subcategory_totals.keys()),
+                'المبلغ': list(indirect_subcategory_totals.values())
+            })
+            
+            fig = px.pie(
+                indirect_subcategory_df,
+                values='المبلغ',
+                names='الفئة الفرعية',
+                title='توزيع التكاليف غير المباشرة حسب الفئة الفرعية'
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            # تجميع البيانات حسب الوصف للتكاليف غير المباشرة
+            indirect_description_totals = {}
+            
+            for item in st.session_state.cost_analysis:
+                if item['category'] == 'تكاليف غير مباشرة':
+                    description = item['description']
+                    if description in indirect_description_totals:
+                        indirect_description_totals[description] += item['amount']
+                    else:
+                        indirect_description_totals[description] = item['amount']
+            
+            indirect_description_df = pd.DataFrame({
+                'الوصف': list(indirect_description_totals.keys()),
+                'المبلغ': list(indirect_description_totals.values())
+            })
+            
+            # ترتيب البيانات تنازلياً حسب المبلغ
+            indirect_description_df = indirect_description_df.sort_values(by='المبلغ', ascending=False)
+            
+            fig = px.bar(
+                indirect_description_df,
+                x='الوصف',
+                y='المبلغ',
+                title='توزيع التكاليف غير المباشرة حسب البند',
+                color='المبلغ',
+                text_auto='.2s'
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # استيراد وتصدير تحليل التكاليف
+        st.markdown("#### استيراد وتصدير تحليل الت��اليف")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if st.button("تصدير تحليل التكاليف إلى Excel", key="export_cost_button"):
+                # محاكاة تصدير البيانات
+                st.success("تم تصدير تحليل التكاليف إلى Excel بنجاح!")
+        
+        with col2:
+            uploaded_file = st.file_uploader("استيراد تحليل التكاليف من Excel", type=["xlsx"], key="import_cost_file")
+            
+            if uploaded_file is not None:
+                if st.button("استيراد البيانات", key="import_cost_button"):
+                    # محاكاة استيراد البيانات
+                    st.success("تم استيراد تحليل التكاليف بنجاح!")
+    
+    def _render_pricing_scenarios_tab(self):
+        """عرض تبويب سيناريوهات التسعير"""
+        
+        st.markdown("### سيناريوهات التسعير")
+        
+        # عرض سيناريوهات التسعير الحالية
+        st.markdown("#### قائمة السيناريوهات")
+        
+        # تحويل قائمة السيناريوهات إلى DataFrame
+        scenarios_df = pd.DataFrame(st.session_state.price_scenarios)
+        
+        # عرض السيناريوهات كجدول قابل للتعديل
+        edited_df = st.data_editor(
+            scenarios_df,
+            column_config={
+                "id": st.column_config.NumberColumn("الرقم", disabled=True),
+                "name": st.column_config.TextColumn("اسم السيناريو"),
+                "description": st.column_config.TextColumn("الوصف"),
+                "total_cost": st.column_config.NumberColumn("إجمالي التكلفة (ريال)", min_value=0, format="%.2f"),
+                "profit_margin": st.column_config.NumberColumn("هامش الربح (%)", min_value=0, format="%.1f"),
+                "total_price": st.column_config.NumberColumn("السعر الإجمالي (ريال)", min_value=0, format="%.2f"),
+                "is_active": st.column_config.CheckboxColumn("نشط")
+            },
+            use_container_width=True,
+            hide_index=True,
+            num_rows="dynamic"
+        )
+        
+        # تحديث قائمة السيناريوهات
+        if not edited_df.equals(scenarios_df):
+            # التأكد من وجود سيناريو نشط واحد فقط
+            active_count = sum(edited_df['is_active'])
+            if active_count != 1:
+                st.error("يجب أن يكون هناك سيناريو نشط واحد فقط.")
+            else:
+                st.session_state.price_scenarios = edited_df.to_dict('records')
+                st.success("تم تحديث سيناريوهات التسعير بنجاح!")
+        
+        # إضافة سيناريو جديد
+        st.markdown("#### إضافة سيناريو جديد")
+        
+        with st.form(key="add_scenario_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                new_name = st.text_input("اسم السيناريو", key="new_scenario_name")
+                new_description = st.text_area("الوصف", key="new_scenario_description")
+            
+            with col2:
+                # حساب إجمالي التكاليف الحالي
+                total_cost = sum(item['amount'] for item in st.session_state.cost_analysis if item['category'] != 'أرباح')
+                
+                st.number_input("إجمالي التكلفة (ريال)", min_value=0.0, value=total_cost, key="new_scenario_total_cost", disabled=True)
+                new_profit_margin = st.number_input("هامش الربح (%)", min_value=0.0, max_value=100.0, value=10.0, key="new_scenario_profit_margin")
+                
+                # حساب السعر الإجمالي
+                new_profit_amount = total_cost * (new_profit_margin / 100)
+                new_total_price = total_cost + new_profit_amount
+                
+                st.number_input("السعر الإجمالي (ريال)", min_value=0.0, value=new_total_price, key="new_scenario_total_price", disabled=True)
+                new_is_active = st.checkbox("نشط", key="new_scenario_is_active")
+            
+            submit_button = st.form_submit_button("إضافة سيناريو")
+        
+        if submit_button:
+            if new_name:
+                # التحقق من حالة التنشيط
+                if new_is_active:
+                    # إلغاء تنشيط جميع السيناريوهات الأخرى
+                    for scenario in st.session_state.price_scenarios:
+                        scenario['is_active'] = False
+                
+                # إنشاء معرف جديد
+                new_id = max([item['id'] for item in st.session_state.price_scenarios], default=0) + 1
+                
+                # إضافة السيناريو الجديد
+                st.session_state.price_scenarios.append({
+                    'id': new_id,
+                    'name': new_name,
+                    'description': new_description,
+                    'total_cost': total_cost,
+                    'profit_margin': new_profit_margin,
+                    'total_price': new_total_price,
+                    'is_active': new_is_active
+                })
+                
+                st.success(f"تمت إضافة السيناريو '{new_name}' بنجاح!")
+                st.rerun()
+            else:
+                st.error("يرجى إدخال اسم السيناريو.")
+        
+        # تحليل السيناريوهات
+        st.markdown("#### تحليل السيناريوهات")
+        
+        # مقارنة السيناريوهات
+        st.markdown("##### مقارنة السيناريوهات")
+        
+        # إنشاء DataFrame للرسم البياني
+        scenarios_comparison_df = pd.DataFrame({
+            'السيناريو': [item['name'] for item in st.session_state.price_scenarios],
+            'التكلفة الإجمالية': [item['total_cost'] for item in st.session_state.price_scenarios],
+            'هامش الربح (%)': [item['profit_margin'] for item in st.session_state.price_scenarios],
+            'السعر الإجمالي': [item['total_price'] for item in st.session_state.price_scenarios],
+            'الحالة': ['نشط' if item['is_active'] else 'غير نشط' for item in st.session_state.price_scenarios]
+        })
+        
+        # إنشاء رسم بياني شريطي مزدوج
+        fig = go.Figure()
+        
+        # إضافة شريط للتكلفة الإجمالية
+        fig.add_trace(go.Bar(
+            x=scenarios_comparison_df['السيناريو'],
+            y=scenarios_comparison_df['التكلفة الإجمالية'],
+            name='التكلفة الإجمالية',
+            marker_color='indianred'
+        ))
+        
+        # إضافة شريط للسعر الإجمالي
+        fig.add_trace(go.Bar(
+            x=scenarios_comparison_df['السيناريو'],
+            y=scenarios_comparison_df['السعر الإجمالي'],
+            name='السعر الإجمالي',
+            marker_color='lightsalmon'
+        ))
+        
+        # إضافة خط لهامش الربح
+        fig.add_trace(go.Scatter(
+            x=scenarios_comparison_df['السيناريو'],
+            y=scenarios_comparison_df['هامش الربح (%)'] * 10000,  # تكبير القيم لتظهر على الرسم البياني
+            name='هامش الربح (%)',
+            yaxis='y2',
+            line=dict(color='royalblue', width=4)
+        ))
+        
+        # تعديل تخطيط الرسم البياني
+        fig.update_layout(
+            title='مقارنة سيناريوهات التسعير',
+            xaxis_title='السيناريو',
+            yaxis_title='المبلغ (ريال)',
+            yaxis2=dict(
+                title='هامش الربح (%)',
+                titlefont=dict(color='royalblue'),
+                tickfont=dict(color='royalblue'),
+                overlaying='y',
+                side='right',
+                range=[0, 20]
+            ),
+            barmode='group',
+            legend=dict(
+                x=0,
+                y=1.2,
+                orientation='h'
+            )
+        )
+        
+        # تعديل النص على الأشرطة
+        fig.update_traces(
+            texttemplate='%{y:,.0f}',
+            textposition='outside'
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # تحليل تأثير هامش الربح
+        st.markdown("##### تحليل تأثير هامش الربح")
+        
+        # إنشاء نطاق من هوامش الربح
+        profit_margins = list(range(0, 21, 2))  # من 0% إلى 20% بزيادة 2%
+        
+        # حساب السعر الإجمالي لكل هامش ربح
+        total_cost = st.session_state.price_scenarios[0]['total_cost']  # استخدام التكلفة الإجمالية من السيناريو الأول
+        total_prices = [total_cost * (1 + margin / 100) for margin in profit_margins]
+        
+        # إنشاء DataFrame للرسم البياني
+        profit_analysis_df = pd.DataFrame({
+            'هامش الربح (%)': profit_margins,
+            'السعر الإجمالي': total_prices
+        })
+        
+        # إنشاء رسم بياني خطي
+        fig = px.line(
+            profit_analysis_df,
+            x='هامش الربح (%)',
+            y='السعر الإجمالي',
+            title='تأثير هامش الربح على السعر الإجمالي',
+            markers=True
+        )
+        
+        # تعديل النص على النقاط
+        fig.update_traces(
+            texttemplate='%{y:,.0f}',
+            textposition='top center'
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # تحليل نقطة التعادل
+        st.markdown("##### تحليل نقطة التعادل")
+        
+        # افتراض تكاليف ثابتة ومتغيرة
+        fixed_costs = sum(item['amount'] for item in st.session_state.cost_analysis if item['category'] == 'تكاليف غير مباشرة')
+        variable_costs = sum(item['amount'] for item in st.session_state.cost_analysis if item['category'] == 'تكاليف مباشرة')
+        
+        # افتراض سعر البيع من السيناريو النشط
+        active_scenario = next((item for item in st.session_state.price_scenarios if item['is_active']), None)
+        if active_scenario:
+            selling_price = active_scenario['total_price']
+        else:
+            selling_price = st.session_state.price_scenarios[0]['total_price']
+        
+        # حساب نقطة التعادل
+        if selling_price > variable_costs:
+            breakeven_point = fixed_costs / (selling_price - variable_costs)
+            st.metric("نقطة التعادل", f"{breakeven_point:.2f} وحدة")
+            
+            # إنشاء رسم بياني لنقطة التعادل
+            units = list(range(0, int(breakeven_point * 2) + 1, max(1, int(breakeven_point / 10))))
+            
+            total_costs = [fixed_costs + variable_costs * unit for unit in units]
+            total_revenues = [selling_price * unit for unit in units]
+            profits = [revenue - cost for revenue, cost in zip(total_revenues, total_costs)]
+            
+            breakeven_df = pd.DataFrame({
+                'الوحدات': units,
+                'إجمالي التكاليف': total_costs,
+                'إجمالي الإيرادات': total_revenues,
+                'الربح': profits
+            })
+            
+            fig = go.Figure()
+            
+            fig.add_trace(go.Scatter(
+                x=breakeven_df['الوحدات'],
+                y=breakeven_df['إجمالي التكاليف'],
+                name='إجمالي التكاليف',
+                line=dict(color='red', width=2)
+            ))
+            
+            fig.add_trace(go.Scatter(
+                x=breakeven_df['الوحدات'],
+                y=breakeven_df['إجمالي الإيرادات'],
+                name='إجمالي الإيرادات',
+                line=dict(color='green', width=2)
+            ))
+            
+            fig.add_trace(go.Scatter(
+                x=breakeven_df['الوحدات'],
+                y=breakeven_df['الربح'],
+                name='الربح',
+                line=dict(color='blue', width=2)
+            ))
+            
+            # إضافة خط عمودي عند نقطة التعادل
+            fig.add_vline(
+                x=breakeven_point,
+                line_dash="dash",
+                line_color="black",
+                annotation_text=f"نقطة التعادل: {breakeven_point:.2f}",
+                annotation_position="top right"
+            )
+            
+            # إضافة خط أفقي عند الصفر
+            fig.add_hline(
+                y=0,
+                line_dash="dash",
+                line_color="gray"
+            )
+            
+            fig.update_layout(
+                title='تحليل نقطة التعادل',
+                xaxis_title='الوحدات',
+                yaxis_title='المبلغ (ريال)'
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+        else:
+            st.warning("لا يمكن حساب نقطة التعادل لأن سعر البيع أقل من التكاليف المتغيرة.")
+    
+    def _render_competitive_analysis_tab(self):
+        """عرض تبويب المقارنة التنافسية"""
+        
+        st.markdown("### المقارنة التنافسية")
+        
+        # بيانات افتراضية للمنافسين
+        competitors_data = [
+            {
+                'name': 'شركتنا',
+                'price': 670000,
+                'quality': 4.5,
+                'delivery_time': 180,
+                'experience': 8,
+                'local_content': 85
+            },
+            {
+                'name': 'المنافس أ',
+                'price': 700000,
+                'quality': 4.2,
+                'delivery_time': 200,
+                'experience': 10,
+                'local_content': 75
+            },
+            {
+                'name': 'المنافس ب',
+                'price': 650000,
+                'quality': 3.8,
+                'delivery_time': 160,
+                'experience': 5,
+                'local_content': 90
+            },
+            {
+                'name': 'المنافس ج',
+                'price': 680000,
+                'quality': 4.0,
+                'delivery_time': 190,
+                'experience': 12,
+                'local_content': 80
+            }
+        ]
+        
+        # عرض بيانات المنافسين
+        st.markdown("#### بيانات المنافسين")
+        
+        competitors_df = pd.DataFrame(competitors_data)
+        st.dataframe(competitors_df, use_container_width=True, hide_index=True)
+        
+        # مقارنة الأسعار
+        st.markdown("#### مقارنة الأسعار")
+        
+        fig = px.bar(
+            competitors_df,
+            x='name',
+            y='price',
+            title='مقارنة الأسعار بين المنافسين',
+            color='price',
+            text_auto='.2s'
+        )
+        
+        fig.update_layout(
+            xaxis_title='المنافس',
+            yaxis_title='السعر (ريال)'
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # مقارنة متعددة الأبعاد
+        st.markdown("#### مقارنة متعددة الأبعاد")
+        
+        # تحويل البيانات إلى تنسيق مناسب للرسم البياني الراداري
+        categories = ['price', 'quality', 'delivery_time', 'experience', 'local_content']
+        
+        # تطبيع البيانات (لجعل القيم بين 0 و 1)
+        normalized_data = {}
+        
+        for category in categories:
+            if category == 'price' or category == 'delivery_time':
+                # للسعر ووقت التسليم، القيمة الأقل أفضل
+                min_val = min(item[category] for item in competitors_data)
+                max_val = max(item[category] for item in competitors_data)
+                normalized_data[category] = [(max_val - item[category]) / (max_val - min_val) if max_val != min_val else 0.5 for item in competitors_data]
+            else:
+                # للجودة والخبرة والمحتوى المحلي، القيمة الأعلى أفضل
+                min_val = min(item[category] for item in competitors_data)
+                max_val = max(item[category] for item in competitors_data)
+                normalized_data[category] = [(item[category] - min_val) / (max_val - min_val) if max_val != min_val else 0.5 for item in competitors_data]
+        
+        # إنشاء الرسم البياني الراداري
+        fig = go.Figure()
+        
+        for i, competitor in enumerate(competitors_data):
+            fig.add_trace(go.Scatterpolar(
+                r=[normalized_data[category][i] for category in categories],
+                theta=['السعر', 'الجودة', 'وقت التسليم', 'الخبرة', 'المحتوى المحلي'],
+                fill='toself',
+                name=competitor['name']
+            ))
+        
+        fig.update_layout(
+            polar=dict(
+                radialaxis=dict(
+                    visible=True,
+                    range=[0, 1]
+                )
+            ),
+            title='مقارنة متعددة الأبعاد بين المنافسين',
+            showlegend=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # تحليل نقاط القوة والضعف
+        st.markdown("#### تحليل نقاط القوة والضعف")
+        
+        # تحديد نقاط القوة والضعف لشركتنا
+        our_company = competitors_data[0]
+        
+        strengths = []
+        weaknesses = []
+        
+        # مقارنة السعر
+        other_prices = [comp['price'] for comp in competitors_data[1:]]
+        if our_company['price'] <= min(other_prices):
+            strengths.append("السعر تنافسي جداً")
+        elif our_company['price'] <= sum(other_prices) / len(other_prices):
+            strengths.append("السعر تنافسي")
+        else:
+            weaknesses.append("السعر أعلى من المتوسط")
+        
+        # مقارنة الجودة
+        other_qualities = [comp['quality'] for comp in competitors_data[1:]]
+        if our_company['quality'] >= max(other_qualities):
+            strengths.append("الجودة ممتازة")
+        elif our_company['quality'] >= sum(other_qualities) / len(other_qualities):
+            strengths.append("الجودة جيدة")
+        else:
+            weaknesses.append("الجودة أقل من المتوسط")
+        
+        # مقارنة وقت التسليم
+        other_delivery_times = [comp['delivery_time'] for comp in competitors_data[1:]]
+        if our_company['delivery_time'] <= min(other_delivery_times):
+            strengths.append("وقت التسليم سريع جداً")
+        elif our_company['delivery_time'] <= sum(other_delivery_times) / len(other_delivery_times):
+            strengths.append("وقت التسليم جيد")
+        else:
+            weaknesses.append("وقت التسليم أطول من المتوسط")
+        
+        # مقارنة الخبرة
+        other_experiences = [comp['experience'] for comp in competitors_data[1:]]
+        if our_company['experience'] >= max(other_experiences):
+            strengths.append("خبرة واسعة جداً")
+        elif our_company['experience'] >= sum(other_experiences) / len(other_experiences):
+            strengths.append("خبرة جيدة")
+        else:
+            weaknesses.append("خبرة أقل من المتوسط")
+        
+        # مقارنة المحتوى المحلي
+        other_local_contents = [comp['local_content'] for comp in competitors_data[1:]]
+        if our_company['local_content'] >= max(other_local_contents):
+            strengths.append("محتوى محلي ممتاز")
+        elif our_company['local_content'] >= sum(other_local_contents) / len(other_local_contents):
+            strengths.append("محتوى محلي جيد")
+        else:
+            weaknesses.append("محتوى محلي أقل من المتوسط")
+        
+        # عرض نقاط القوة والضعف
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("##### نقاط القوة")
+            for strength in strengths:
+                st.markdown(f"- {strength}")
+        
+        with col2:
+            st.markdown("##### نقاط الضعف")
+            for weakness in weaknesses:
+                st.markdown(f"- {weakness}")
+        
+        # توصيات للتسعير
+        st.markdown("#### توصيات للتسعير")
+        
+        # تحديد التوصيات بناءً على المقارنة
+        recommendations = []
+        
+        # توصية بناءً على السعر
+        avg_price = sum(comp['price'] for comp in competitors_data) / len(competitors_data)
+        if our_company['price'] > avg_price:
+            recommendations.append("النظر في تخفيض السعر للمنافسة بشكل أفضل.")
+        
+        # توصية بناءً على الجودة
+        if our_company['quality'] > sum(comp['quality'] for comp in competitors_data[1:]) / len(competitors_data[1:]):
+            recommendations.append("التأكيد على جودة الخدمات في العروض التسويقية.")
+        
+        # توصية بناءً على وقت التسليم
+        if our_company['delivery_time'] < sum(comp['delivery_time'] for comp in competitors_data[1:]) / len(competitors_data[1:]):
+            recommendations.append("التأكيد على سرعة التسليم كميزة تنافسية.")
+        
+        # توصية بناءً على الخبرة
+        if our_company['experience'] < max(comp['experience'] for comp in competitors_data[1:]):
+            recommendations.append("تعزيز فريق العمل بخبرات إضافية.")
+        
+        # توصية بناءً على المحتوى المحلي
+        if our_company['local_content'] > sum(comp['local_content'] for comp in competitors_data[1:]) / len(competitors_data[1:]):
+            recommendations.append("التأكيد على نسبة المحتوى المحلي العالية في العروض.")
+        
+        # توصية عامة
+        recommendations.append("مراجعة هيكل التكاليف بشكل دوري للحفاظ على القدرة التنافسية.")
+        
+        # عرض التوصيات
+        for recommendation in recommendations:
+            st.markdown(f"- {recommendation}")
+    
+    def _render_reports_tab(self):
+        """عرض تبويب التقارير"""
+        
+        st.markdown("### التقارير")
+        
+        # قائمة التقارير المتاحة
+        reports = [
+            "تقرير جدول الكميات",
+            "تقرير تحليل التكاليف",
+            "تقرير سيناريوهات التسعير",
+            "تقرير المقارنة التنافسية",
+            "تقرير ملخص التسعير"
+        ]
+        
+        # اختيار التقرير
+        selected_report = st.selectbox("اختر التقرير", reports)
+        
+        # خيارات التصدير
+        export_format = st.radio("صيغة التصدير", ["PDF", "Excel", "Word"])
+        
+        # زر إنشاء التقرير
+        if st.button("إنشاء التقرير"):
+            st.success(f"تم إنشاء {selected_report} بصيغة {export_format} بنجاح!")
+        
+        # عرض نموذج للتقرير
+        st.markdown("#### نموذج التقرير")
+        
+        if selected_report == "تقرير جدول الكميات":
+            self._render_boq_report()
+        elif selected_report == "تقرير تحليل التكاليف":
+            self._render_cost_analysis_report()
+        elif selected_report == "تقرير سيناريوهات التسعير":
+            self._render_pricing_scenarios_report()
+        elif selected_report == "تقرير المقارنة التنافسية":
+            self._render_competitive_analysis_report()
+        elif selected_report == "تقرير ملخص ��لتسعير":
+            self._render_pricing_summary_report()
+    
+    def _render_boq_report(self):
+        """عرض نموذج تقرير جدول الكميات"""
+        
+        st.markdown("### تقرير جدول الكميات")
+        st.markdown("**تاريخ التقرير:** " + time.strftime("%Y-%m-%d"))
+        st.markdown("**اسم المشروع:** مشروع إنشاء مبنى إداري")
+        st.markdown("**رقم المناقصة:** T-2024-001")
+        
+        st.markdown("#### جدول الكميات")
+        
+        # عرض جدول الكميات
+        boq_df = pd.DataFrame(st.session_state.bill_of_quantities)
+        st.dataframe(boq_df, use_container_width=True, hide_index=True)
+        
+        # عرض إجمالي جدول الكميات
+        total_boq = sum(item['total_price'] for item in st.session_state.bill_of_quantities)
+        st.metric("إجمالي جدول الكميات", f"{total_boq:,.2f} ريال")
+        
+        # عرض توزيع البنود حسب الفئة
+        st.markdown("#### توزيع البنود حسب الفئة")
+        
+        # تجميع البيانات حسب الفئة
+        category_totals = {}
+        
+        for item in st.session_state.bill_of_quantities:
+            category = item['category']
+            if category in category_totals:
+                category_totals[category] += item['total_price']
+            else:
+                category_totals[category] = item['total_price']
+        
+        category_df = pd.DataFrame({
+            'الفئة': list(category_totals.keys()),
+            'المبلغ': list(category_totals.values())
+        })
+        
+        fig = px.pie(
+            category_df,
+            values='المبلغ',
+            names='الفئة',
+            title='توزيع جدول الكميات حسب الفئة'
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_cost_analysis_report(self):
+        """عرض نموذج تقرير تحليل التكاليف"""
+        
+        st.markdown("### تقرير تحليل التكاليف")
+        st.markdown("**تاريخ التقرير:** " + time.strftime("%Y-%m-%d"))
+        st.markdown("**اسم المشروع:** مشروع إنشاء مبنى إداري")
+        st.markdown("**رقم المناقصة:** T-2024-001")
+        
+        st.markdown("#### تحليل التكاليف")
+        
+        # عرض تحليل التكاليف
+        cost_df = pd.DataFrame(st.session_state.cost_analysis)
+        st.dataframe(cost_df, use_container_width=True, hide_index=True)
+        
+        # عرض إجمالي التكاليف
+        total_cost = sum(item['amount'] for item in st.session_state.cost_analysis)
+        st.metric("إجمالي التكاليف", f"{total_cost:,.2f} ريال")
+        
+        # عرض توزيع التكاليف حسب الفئة
+        st.markdown("#### توزيع التكاليف حسب الفئة")
+        
+        # تجميع البيانات حسب الفئة
+        category_totals = {}
+        
+        for item in st.session_state.cost_analysis:
+            category = item['category']
+            if category in category_totals:
+                category_totals[category] += item['amount']
+            else:
+                category_totals[category] = item['amount']
+        
+        category_df = pd.DataFrame({
+            'الفئة': list(category_totals.keys()),
+            'المبلغ': list(category_totals.values())
+        })
+        
+        fig = px.pie(
+            category_df,
+            values='المبلغ',
+            names='الفئة',
+            title='توزيع التكاليف حسب الفئة'
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع التكاليف المباشرة
+        st.markdown("#### توزيع التكاليف المباشرة")
+        
+        # تجميع البيانات حسب الفئة الفرعية للتكاليف المباشرة
+        direct_subcategory_totals = {}
+        
+        for item in st.session_state.cost_analysis:
+            if item['category'] == 'تكاليف مباشرة':
+                subcategory = item['subcategory']
+                if subcategory in direct_subcategory_totals:
+                    direct_subcategory_totals[subcategory] += item['amount']
+                else:
+                    direct_subcategory_totals[subcategory] = item['amount']
+        
+        direct_subcategory_df = pd.DataFrame({
+            'الفئة الفرعية': list(direct_subcategory_totals.keys()),
+            'المبلغ': list(direct_subcategory_totals.values())
+        })
+        
+        fig = px.bar(
+            direct_subcategory_df,
+            x='الفئة الفرعية',
+            y='المبلغ',
+            title='توزيع التكاليف المباشرة',
+            color='الفئة الفرعية',
+            text_auto='.2s'
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_pricing_scenarios_report(self):
+        """عرض نموذج تقرير سيناريوهات التسعير"""
+        
+        st.markdown("### تقرير سيناريوهات التسعير")
+        st.markdown("**تاريخ التقرير:** " + time.strftime("%Y-%m-%d"))
+        st.markdown("**اسم المشروع:** مشروع إنشاء مبنى إداري")
+        st.markdown("**رقم المناقصة:** T-2024-001")
+        
+        st.markdown("#### سيناريوهات التسعير")
+        
+        # عرض سيناريوهات التسعير
+        scenarios_df = pd.DataFrame(st.session_state.price_scenarios)
+        st.dataframe(scenarios_df, use_container_width=True, hide_index=True)
+        
+        # عرض السيناريو النشط
+        active_scenario = next((item for item in st.session_state.price_scenarios if item['is_active']), None)
+        if active_scenario:
+            st.markdown(f"**السيناريو النشط:** {active_scenario['name']}")
+            st.markdown(f"**السعر الإجمالي:** {active_scenario['total_price']:,.2f} ريال")
+            st.markdown(f"**هامش الربح:** {active_scenario['profit_margin']:.1f}%")
+        
+        # عرض مقارنة السيناريوهات
+        st.markdown("#### مقارنة السيناريوهات")
+        
+        # إنشاء DataFrame للرسم البياني
+        scenarios_comparison_df = pd.DataFrame({
+            'السيناريو': [item['name'] for item in st.session_state.price_scenarios],
+            'التكلفة الإجمالية': [item['total_cost'] for item in st.session_state.price_scenarios],
+            'هامش الربح (%)': [item['profit_margin'] for item in st.session_state.price_scenarios],
+            'السعر الإجمالي': [item['total_price'] for item in st.session_state.price_scenarios],
+            'الحالة': ['نشط' if item['is_active'] else 'غير نشط' for item in st.session_state.price_scenarios]
+        })
+        
+        # إنشاء رسم بياني شريطي مزدوج
+        fig = go.Figure()
+        
+        # إضافة شريط للتكلفة الإجمالية
+        fig.add_trace(go.Bar(
+            x=scenarios_comparison_df['السيناريو'],
+            y=scenarios_comparison_df['التكلفة الإجمالية'],
+            name='التكلفة الإجمالية',
+            marker_color='indianred'
+        ))
+        
+        # إضافة شريط للسعر الإجمالي
+        fig.add_trace(go.Bar(
+            x=scenarios_comparison_df['السيناريو'],
+            y=scenarios_comparison_df['السعر الإجمالي'],
+            name='السعر الإجمالي',
+            marker_color='lightsalmon'
+        ))
+        
+        # إضافة خط لهامش الربح
+        fig.add_trace(go.Scatter(
+            x=scenarios_comparison_df['السيناريو'],
+            y=scenarios_comparison_df['هامش الربح (%)'] * 10000,  # تكبير القيم لتظهر على الرسم البياني
+            name='هامش الربح (%)',
+            yaxis='y2',
+            line=dict(color='royalblue', width=4)
+        ))
+        
+        # تعديل تخطيط الرسم البياني
+        fig.update_layout(
+            title='مقارنة سيناريوهات التسعير',
+            xaxis_title='السيناريو',
+            yaxis_title='المبلغ (ريال)',
+            yaxis2=dict(
+                title='هامش الربح (%)',
+                titlefont=dict(color='royalblue'),
+                tickfont=dict(color='royalblue'),
+                overlaying='y',
+                side='right',
+                range=[0, 20]
+            ),
+            barmode='group',
+            legend=dict(
+                x=0,
+                y=1.2,
+                orientation='h'
+            )
+        )
+        
+        # تعديل النص على الأشرطة
+        fig.update_traces(
+            texttemplate='%{y:,.0f}',
+            textposition='outside'
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_competitive_analysis_report(self):
+        """عرض نموذج تقرير المقارنة التنافسية"""
+        
+        st.markdown("### تقرير المقارنة التنافسية")
+        st.markdown("**تاريخ التقرير:** " + time.strftime("%Y-%m-%d"))
+        st.markdown("**اسم المشروع:** مشروع إنشاء مبنى إداري")
+        st.markdown("**رقم المناقصة:** T-2024-001")
+        
+        # بيانات افتراضية للمنافسين
+        competitors_data = [
+            {
+                'name': 'شركتنا',
+                'price': 670000,
+                'quality': 4.5,
+                'delivery_time': 180,
+                'experience': 8,
+                'local_content': 85
+            },
+            {
+                'name': 'المنافس أ',
+                'price': 700000,
+                'quality': 4.2,
+                'delivery_time': 200,
+                'experience': 10,
+                'local_content': 75
+            },
+            {
+                'name': 'المنافس ب',
+                'price': 650000,
+                'quality': 3.8,
+                'delivery_time': 160,
+                'experience': 5,
+                'local_content': 90
+            },
+            {
+                'name': 'المنافس ج',
+                'price': 680000,
+                'quality': 4.0,
+                'delivery_time': 190,
+                'experience': 12,
+                'local_content': 80
+            }
+        ]
+        
+        # عرض بيانات المنافسين
+        st.markdown("#### بيانات المنافسين")
+        
+        competitors_df = pd.DataFrame(competitors_data)
+        st.dataframe(competitors_df, use_container_width=True, hide_index=True)
+        
+        # مقارنة الأسعار
+        st.markdown("#### مقارنة الأسعار")
+        
+        fig = px.bar(
+            competitors_df,
+            x='name',
+            y='price',
+            title='مقارنة الأسعار بين المنافسين',
+            color='price',
+            text_auto='.2s'
+        )
+        
+        fig.update_layout(
+            xaxis_title='المنافس',
+            yaxis_title='السعر (ريال)'
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # مقارنة متعددة الأبعاد
+        st.markdown("#### مقارنة متعددة الأبعاد")
+        
+        # تحويل البيانات إلى تنسيق مناسب للرسم البياني الراداري
+        categories = ['price', 'quality', 'delivery_time', 'experience', 'local_content']
+        
+        # تطبيع البيانات (لجعل القيم بين 0 و 1)
+        normalized_data = {}
+        
+        for category in categories:
+            if category == 'price' or category == 'delivery_time':
+                # للسعر ووقت التسليم، القيمة الأقل أفضل
+                min_val = min(item[category] for item in competitors_data)
+                max_val = max(item[category] for item in competitors_data)
+                normalized_data[category] = [(max_val - item[category]) / (max_val - min_val) if max_val != min_val else 0.5 for item in competitors_data]
+            else:
+                # للجودة والخبرة والمحتوى المحلي، القيمة الأعلى أفضل
+                min_val = min(item[category] for item in competitors_data)
+                max_val = max(item[category] for item in competitors_data)
+                normalized_data[category] = [(item[category] - min_val) / (max_val - min_val) if max_val != min_val else 0.5 for item in competitors_data]
+        
+        # إنشاء الرسم البياني الراداري
+        fig = go.Figure()
+        
+        for i, competitor in enumerate(competitors_data):
+            fig.add_trace(go.Scatterpolar(
+                r=[normalized_data[category][i] for category in categories],
+                theta=['السعر', 'الجودة', 'وقت التسليم', 'الخبرة', 'المحتوى المحلي'],
+                fill='toself',
+                name=competitor['name']
+            ))
+        
+        fig.update_layout(
+            polar=dict(
+                radialaxis=dict(
+                    visible=True,
+                    range=[0, 1]
+                )
+            ),
+            title='مقارنة متعددة الأبعاد بين المنافسين',
+            showlegend=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_pricing_summary_report(self):
+        """عرض نموذج تقرير ملخص التسعير"""
+        
+        st.markdown("### تقرير ملخص التسعير")
+        st.markdown("**تاريخ التقرير:** " + time.strftime("%Y-%m-%d"))
+        st.markdown("**اسم المشروع:** مشروع إنشاء مبنى إداري")
+        st.markdown("**رقم المناقصة:** T-2024-001")
+        
+        # عرض ملخص التسعير
+        st.markdown("#### ملخص التسعير")
+        
+        # حساب إجمالي التكاليف
+        total_direct_cost = sum(item['amount'] for item in st.session_state.cost_analysis if item['category'] == 'تكاليف مباشرة')
+        total_indirect_cost = sum(item['amount'] for item in st.session_state.cost_analysis if item['category'] == 'تكاليف غير مباشرة')
+        total_profit = sum(item['amount'] for item in st.session_state.cost_analysis if item['category'] == 'أرباح')
+        total_cost = total_direct_cost + total_indirect_cost
+        total_price = total_cost + total_profit
+        
+        # إنشاء ج��ول ملخص
+        summary_data = {
+            'البند': ['التكاليف المباشرة', 'التكاليف غير المباشرة', 'إجمالي التكاليف', 'هامش الربح', 'السعر الإجمالي'],
+            'المبلغ (ريال)': [total_direct_cost, total_indirect_cost, total_cost, total_profit, total_price],
+            'النسبة (%)': [
+                (total_direct_cost / total_price) * 100,
+                (total_indirect_cost / total_price) * 100,
+                (total_cost / total_price) * 100,
+                (total_profit / total_price) * 100,
+                100.0
+            ]
+        }
+        
+        summary_df = pd.DataFrame(summary_data)
+        st.dataframe(summary_df, use_container_width=True, hide_index=True)
+        
+        # عرض توزيع التكاليف
+        st.markdown("#### توزيع التكاليف")
+        
+        # إنشاء DataFrame للرسم البياني
+        cost_distribution_df = pd.DataFrame({
+            'البند': ['التكاليف المباشرة', 'التكاليف غير المباشرة', 'هامش الربح'],
+            'المبلغ': [total_direct_cost, total_indirect_cost, total_profit]
+        })
+        
+        fig = px.pie(
+            cost_distribution_df,
+            values='المبلغ',
+            names='البند',
+            title='توزيع التكاليف والأرباح',
+            color_discrete_sequence=px.colors.qualitative.Set3
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض ملخص السيناريو النشط
+        st.markdown("#### السيناريو النشط")
+        
+        active_scenario = next((item for item in st.session_state.price_scenarios if item['is_active']), None)
+        if active_scenario:
+            st.markdown(f"**اسم السيناريو:** {active_scenario['name']}")
+            st.markdown(f"**الوصف:** {active_scenario['description']}")
+            st.markdown(f"**إجمالي التكلفة:** {active_scenario['total_cost']:,.2f} ريال")
+            st.markdown(f"**هامش الربح:** {active_scenario['profit_margin']:.1f}%")
+            st.markdown(f"**السعر الإجمالي:** {active_scenario['total_price']:,.2f} ريال")
+        
+        # عرض توصيات التسعير
+        st.markdown("#### توصيات التسعير")
+        
+        st.markdown("- مراجعة هيكل التكاليف بشكل دوري للحفاظ على القدرة التنافسية.")
+        st.markdown("- التأكيد على جودة الخدمات في العروض التسويقية.")
+        st.markdown("- التأكيد على نسبة المحتوى المحلي العالية في العروض.")
+        st.markdown("- مراقبة أسعار المنافسين وتعديل الاستراتيجية التسعيرية عند الحاجة.")
+        st.markdown("- تحليل نقاط القوة والضعف بشكل مستمر لتحسين العروض المستقبلية.")

modules/pricing/pricing_engine.py

@@ -0,0 +1,430 @@
+"""
+وحدة التسعير المتكامل لنظام إدارة المناقصات - Hybrid Face
+"""
+
+import os
+import logging
+import threading
+import datetime
+import json
+import math
+from pathlib import Path
+
+# تهيئة السجل
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger('pricing')
+
+class PricingEngine:
+    """محرك التسعير المتكامل"""
+    
+    def __init__(self, config=None, db=None):
+        """تهيئة محرك التسعير"""
+        self.config = config
+        self.db = db
+        self.pricing_in_progress = False
+        self.current_project = None
+        self.pricing_results = {}
+        
+        # إنشاء مجلد التسعير إذا لم يكن موجوداً
+        if config and hasattr(config, 'EXPORTS_PATH'):
+            self.exports_path = Path(config.EXPORTS_PATH)
+        else:
+            self.exports_path = Path('data/exports')
+            
+        if not self.exports_path.exists():
+            self.exports_path.mkdir(parents=True, exist_ok=True)
+    
+    def calculate_pricing(self, project_id, strategy="comprehensive", callback=None):
+        """حساب التسعير للمشروع"""
+        if self.pricing_in_progress:
+            logger.warning("هناك عملية تسعير جارية بالفعل")
+            return False
+        
+        self.pricing_in_progress = True
+        self.current_project = project_id
+        self.pricing_results = {
+            "project_id": project_id,
+            "strategy": strategy,
+            "pricing_start_time": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+            "status": "جاري التسعير",
+            "direct_costs": {},
+            "indirect_costs": {},
+            "risk_costs": {},
+            "summary": {}
+        }
+        
+        # بدء التسعير في خيط منفصل
+        thread = threading.Thread(
+            target=self._calculate_pricing_thread,
+            args=(project_id, strategy, callback)
+        )
+        thread.daemon = True
+        thread.start()
+        
+        return True
+    
+    def _calculate_pricing_thread(self, project_id, strategy, callback):
+        """خيط حساب التسعير"""
+        try:
+            # محاكاة جلب بيانات المشروع من قاعدة البيانات
+            project_data = self._get_project_data(project_id)
+            
+            if not project_data:
+                logger.error(f"لم يتم العثور على بيانات المشروع: {project_id}")
+                self.pricing_results["status"] = "فشل التسعير"
+                self.pricing_results["error"] = "لم يتم العثور على بيانات المشروع"
+                return
+            
+            # حساب التكاليف المباشرة
+            self._calculate_direct_costs(project_data)
+            
+            # حساب التكاليف غير المباشرة
+            self._calculate_indirect_costs(project_data, strategy)
+            
+            # حساب تكاليف المخاطر
+            self._calculate_risk_costs(project_data, strategy)
+            
+            # حساب ملخص التسعير
+            self._calculate_pricing_summary(strategy)
+            
+            # تحديث حالة التسعير
+            self.pricing_results["status"] = "اكتمل التسعير"
+            self.pricing_results["pricing_end_time"] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            
+            logger.info(f"اكتمل تسعير المشروع: {project_id}")
+            
+        except Exception as e:
+            logger.error(f"خطأ في تسعير المشروع: {str(e)}")
+            self.pricing_results["status"] = "فشل التسعير"
+            self.pricing_results["error"] = str(e)
+        
+        finally:
+            self.pricing_in_progress = False
+            
+            # استدعاء دالة الاستجابة إذا تم توفيرها
+            if callback and callable(callback):
+                callback(self.pricing_results)
+    
+    def _get_project_data(self, project_id):
+        """الحصول على بيانات المشروع"""
+        # في التطبيق الفعلي، سيتم جلب البيانات من قاعدة البيانات
+        # هنا نقوم بمحاكاة البيانات للتوضيح
+        
+        return {
+            "id": project_id,
+            "name": "مشروع الطرق السريعة",
+            "client": "وزارة النقل",
+            "items": [
+                {"id": 1, "name": "أعمال الحفر", "unit": "م³", "quantity": 1500, "unit_cost": 45},
+                {"id": 2, "name": "أعمال الخرسانة", "unit": "م³", "quantity": 750, "unit_cost": 1200},
+                {"id": 3, "name": "أعمال الأسفلت", "unit": "م²", "quantity": 5000, "unit_cost": 120},
+                {"id": 4, "name": "أعمال الإنارة", "unit": "عدد", "quantity": 50, "unit_cost": 3500}
+            ],
+            "resources": {
+                "materials": [
+                    {"id": 1, "name": "أسمنت", "unit": "طن", "quantity": 300, "unit_cost": 950},
+                    {"id": 2, "name": "حديد تسليح", "unit": "طن", "quantity": 120, "unit_cost": 3200},
+                    {"id": 3, "name": "رمل", "unit": "م³", "quantity": 450, "unit_cost": 75},
+                    {"id": 4, "name": "أسفلت", "unit": "طن", "quantity": 200, "unit_cost": 1800}
+                ],
+                "equipment": [
+                    {"id": 1, "name": "حفارة", "unit": "يوم", "quantity": 45, "unit_cost": 1500},
+                    {"id": 2, "name": "لودر", "unit": "يوم", "quantity": 30, "unit_cost": 1200},
+                    {"id": 3, "name": "شاحنة نقل", "unit": "يوم", "quantity": 60, "unit_cost": 800},
+                    {"id": 4, "name": "خلاطة خرسانة", "unit": "يوم", "quantity": 40, "unit_cost": 600}
+                ],
+                "labor": [
+                    {"id": 1, "name": "عمال", "unit": "يوم", "quantity": 1200, "unit_cost": 150},
+                    {"id": 2, "name": "فنيون", "unit": "يوم", "quantity": 600, "unit_cost": 300},
+                    {"id": 3, "name": "مهندسون", "unit": "يوم", "quantity": 180, "unit_cost": 800}
+                ]
+            },
+            "risks": [
+                {"id": 1, "name": "تأخر توريد المواد", "probability": "متوسط", "impact": "عالي", "cost_impact": 0.05},
+                {"id": 2, "name": "تغير أسعار المواد", "probability": "عالي", "impact": "عالي", "cost_impact": 0.08},
+                {"id": 3, "name": "ظروف جوية غير مواتية", "probability": "منخفض", "impact": "متوسط", "cost_impact": 0.03},
+                {"id": 4, "name": "نقص العمالة", "probability": "متوسط", "impact": "متوسط", "cost_impact": 0.04}
+            ],
+            "project_duration": 180,  # بالأيام
+            "location": "المنطقة الشرقية"
+        }
+    
+    def _calculate_direct_costs(self, project_data):
+        """حساب التكاليف المباشرة"""
+        # حساب تكاليف البنود
+        items_cost = 0
+        items_details = []
+        
+        for item in project_data["items"]:
+            total_cost = item["quantity"] * item["unit_cost"]
+            items_cost += total_cost
+            
+            items_details.append({
+                "id": item["id"],
+                "name": item["name"],
+                "unit": item["unit"],
+                "quantity": item["quantity"],
+                "unit_cost": item["unit_cost"],
+                "total_cost": total_cost
+            })
+        
+        # حساب تكاليف الموارد
+        materials_cost = 0
+        equipment_cost = 0
+        labor_cost = 0
+        
+        for material in project_data["resources"]["materials"]:
+            materials_cost += material["quantity"] * material["unit_cost"]
+        
+        for equipment in project_data["resources"]["equipment"]:
+            equipment_cost += equipment["quantity"] * equipment["unit_cost"]
+        
+        for labor in project_data["resources"]["labor"]:
+            labor_cost += labor["quantity"] * labor["unit_cost"]
+        
+        resources_cost = materials_cost + equipment_cost + labor_cost
+        
+        # تخزين نتائج التكاليف المباشرة
+        self.pricing_results["direct_costs"] = {
+            "items": {
+                "total": items_cost,
+                "details": items_details
+            },
+            "resources": {
+                "total": resources_cost,
+                "materials": materials_cost,
+                "equipment": equipment_cost,
+                "labor": labor_cost
+            },
+            "total_direct_costs": items_cost
+        }
+    
+    def _calculate_indirect_costs(self, project_data, strategy):
+        """حساب التكاليف غير المباشرة"""
+        direct_costs = self.pricing_results["direct_costs"]["total_direct_costs"]
+        
+        # تحديد نسب التكاليف غير المباشرة بناءً على استراتيجية التسعير
+        if strategy == "comprehensive":
+            overhead_rate = 0.15  # 15% نفقات عامة
+            profit_rate = 0.10    # 10% ربح
+            admin_rate = 0.05     # 5% تكاليف إدارية
+        elif strategy == "competitive":
+            overhead_rate = 0.12  # 12% نفقات عامة
+            profit_rate = 0.07    # 7% ربح
+            admin_rate = 0.04     # 4% تكاليف إدارية
+        else:  # balanced
+            overhead_rate = 0.13  # 13% نفقات عامة
+            profit_rate = 0.08    # 8% ربح
+            admin_rate = 0.045    # 4.5% تكاليف إدارية
+        
+        # حساب التكاليف غير المباشرة
+        overhead_cost = direct_costs * overhead_rate
+        profit_cost = direct_costs * profit_rate
+        admin_cost = direct_costs * admin_rate
+        
+        # تكاليف إضافية
+        mobilization_cost = direct_costs * 0.03  # 3% تكاليف التجهيز
+        bonds_insurance_cost = direct_costs * 0.02  # 2% تكاليف الضمانات والتأمين
+        
+        # إجمالي التكاليف غير المباشرة
+        total_indirect_costs = overhead_cost + profit_cost + admin_cost + mobilization_cost + bonds_insurance_cost
+        
+        # تخزين نتائج التكاليف غير المباشرة
+        self.pricing_results["indirect_costs"] = {
+            "overhead": {
+                "rate": overhead_rate,
+                "cost": overhead_cost
+            },
+            "profit": {
+                "rate": profit_rate,
+                "cost": profit_cost
+            },
+            "administrative": {
+                "rate": admin_rate,
+                "cost": admin_cost
+            },
+            "mobilization": {
+                "rate": 0.03,
+                "cost": mobilization_cost
+            },
+            "bonds_insurance": {
+                "rate": 0.02,
+                "cost": bonds_insurance_cost
+            },
+            "total_indirect_costs": total_indirect_costs
+        }
+    
+    def _calculate_risk_costs(self, project_data, strategy):
+        """حساب تكاليف المخاطر"""
+        direct_costs = self.pricing_results["direct_costs"]["total_direct_costs"]
+        
+        # تحويل احتمالية وتأثير المخاطر إلى قيم رقمية
+        probability_map = {
+            "منخفض": 0.3,
+            "متوسط": 0.5,
+            "عالي": 0.7
+        }
+        
+        impact_map = {
+            "منخفض": 0.3,
+            "متوسط": 0.5,
+            "عالي": 0.7
+        }
+        
+        # حساب تكاليف المخاطر
+        risk_costs = []
+        total_risk_cost = 0
+        
+        for risk in project_data["risks"]:
+            probability = probability_map.get(risk["probability"], 0.5)
+            impact = impact_map.get(risk["impact"], 0.5)
+            
+            # حساب درجة المخاطرة
+            risk_score = probability * impact
+            
+            # حساب تكلفة المخاطرة
+            risk_cost = direct_costs * risk["cost_impact"] * risk_score
+            
+            # تعديل تكلفة المخاطرة بناءً على استراتيجية التسعير
+            if strategy == "comprehensive":
+                risk_cost_factor = 1.0  # تغطية كاملة للمخاطر
+            elif strategy == "competitive":
+                risk_cost_factor = 0.7  # تغطية جزئية للمخاطر
+            else:  # balanced
+                risk_cost_factor = 0.85  # تغطية متوازنة للمخاطر
+            
+            adjusted_risk_cost = risk_cost * risk_cost_factor
+            total_risk_cost += adjusted_risk_cost
+            
+            risk_costs.append({
+                "id": risk["id"],
+                "name": risk["name"],
+                "probability": risk["probability"],
+                "impact": risk["impact"],
+                "risk_score": risk_score,
+                "cost_impact": risk["cost_impact"],
+                "risk_cost": risk_cost,
+                "adjusted_risk_cost": adjusted_risk_cost
+            })
+        
+        # تخزين نتائج تكاليف المخاطر
+        self.pricing_results["risk_costs"] = {
+            "risks": risk_costs,
+            "total_risk_cost": total_risk_cost,
+            "strategy_factor": 1.0 if strategy == "comprehensive" else (0.7 if strategy == "competitive" else 0.85)
+        }
+    
+    def _calculate_pricing_summary(self, strategy):
+        """حساب ملخص التسعير"""
+        direct_costs = self.pricing_results["direct_costs"]["total_direct_costs"]
+        indirect_costs = self.pricing_results["indirect_costs"]["total_indirect_costs"]
+        risk_costs = self.pricing_results["risk_costs"]["total_risk_cost"]
+        
+        # حساب إجمالي التكاليف
+        total_costs = direct_costs + indirect_costs + risk_costs
+        
+        # حساب ضريبة القيمة المضافة (15%)
+        vat = total_costs * 0.15
+        
+        # حساب السعر النهائي
+        final_price = total_costs + vat
+        
+        # تخزين ملخص التسعير
+        self.pricing_results["summary"] = {
+            "direct_costs": direct_costs,
+            "indirect_costs": indirect_costs,
+            "risk_costs": risk_costs,
+            "total_costs": total_costs,
+            "vat": {
+                "rate": 0.15,
+                "amount": vat
+            },
+            "final_price": final_price,
+            "strategy": strategy,
+            "pricing_notes": self._generate_pricing_notes(strategy)
+        }
+    
+    def _generate_pricing_notes(self, strategy):
+        """توليد ملاحظات التسعير"""
+        if strategy == "comprehensive":
+            return [
+                "تم تطبيق استراتيجية التسعير الشاملة التي تغطي جميع التكاليف والمخاطر",
+                "تم تضمين هامش ربح مناسب (10%) لضمان ربحية المشروع",
+                "تم تغطية جميع المخاطر المحتملة بشكل كامل",
+                "يوصى بمراجعة أسعار المواد قبل تقديم العرض النهائي"
+            ]
+        elif strategy == "competitive":
+            return [
+                "تم تطبيق استراتيجية التسعير التنافسية لزيادة فرص الفوز بالمناقصة",
+                "تم تخفيض هامش الربح (7%) لتقديم سعر تنافسي",
+                "تم تغطية المخاطر بشكل جزئي، مما يتطلب إدارة مخاطر فعالة أثناء التنفيذ",
+                "يجب مراقبة التكاليف بدقة أثناء تنفيذ المشروع لضمان الربحية"
+            ]
+        else:  # balanced
+            return [
+                "تم تطبيق استراتيجية التسعير المتوازنة التي توازن بين الربحية والتنافسية",
+                "تم تضمين هامش ربح معقول (8%) يوازن بين الربحية والتنافسية",
+                "تم تغطية المخاطر الرئيسية بشكل مناسب",
+                "يوصى بمراجعة بنود التكلفة العالية قبل تقديم العرض النهائي"
+            ]
+    
+    def get_pricing_status(self):
+        """الحصول على حالة التسعير الحالي"""
+        if not self.pricing_in_progress:
+            if not self.pricing_results:
+                return {"status": "لا يوجد تسعير جارٍ"}
+            else:
+                return {"status": self.pricing_results.get("status", "غير معروف")}
+        
+        return {
+            "status": "جاري التسعير",
+            "project_id": self.current_project,
+            "start_time": self.pricing_results.get("pricing_start_time")
+        }
+    
+    def get_pricing_results(self):
+        """الحصول على نتائج التسعير"""
+        return self.pricing_results
+    
+    def export_pricing_results(self, output_path=None):
+        """تصدير نتائج التسعير إلى ملف JSON"""
+        if not self.pricing_results:
+            logger.warning("لا توجد نتائج تسعير للتصدير")
+            return None
+        
+        if not output_path:
+            # إنشاء اسم ملف افتراضي
+            timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+            filename = f"pricing_results_{timestamp}.json"
+            output_path = os.path.join(self.exports_path, filename)
+        
+        try:
+            with open(output_path, 'w', encoding='utf-8') as f:
+                json.dump(self.pricing_results, f, ensure_ascii=False, indent=4)
+            
+            logger.info(f"تم تصدير نتائج التسعير إلى: {output_path}")
+            return output_path
+        
+        except Exception as e:
+            logger.error(f"خطأ في تصدير نتائج التسعير: {str(e)}")
+            return None
+    
+    def import_pricing_results(self, input_path):
+        """استيراد نتائج التسعير من ملف JSON"""
+        if not os.path.exists(input_path):
+            logger.error(f"ملف نتائج التسعير غير موجود: {input_path}")
+            return False
+        
+        try:
+            with open(input_path, 'r', encoding='utf-8') as f:
+                self.pricing_results = json.load(f)
+            
+            logger.info(f"تم استيراد نتائج التسعير من: {input_path}")
+            return True
+        
+        except Exception as e:
+            logger.error(f"خطأ في استيراد نتائج التسعير: {str(e)}")
+            return False

modules/project_management/project_management_app.py

@@ -0,0 +1,666 @@
+"""
+وحدة إدارة المشاريع - نظام تحليل المناقصات
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import os
+import time
+import io
+import sys
+from pathlib import Path
+
+# إضافة مسار المشروع للنظام
+sys.path.append(str(Path(__file__).parent.parent))
+
+# استيراد محسن واجهة المستخدم
+from styling.enhanced_ui import UIEnhancer
+
+class ProjectsApp:
+    """وحدة إدارة المشاريع"""
+    
+    def __init__(self):
+        """تهيئة وحدة إدارة المشاريع"""
+        self.ui = UIEnhancer(page_title="إدارة المشاريع - نظام تحليل المناقصات", page_icon="📋")
+        self.ui.apply_theme_colors()
+        
+        # تهيئة البيانات المبدئية
+        if 'projects' not in st.session_state:
+            st.session_state.projects = self._generate_sample_projects()
+    
+    def run(self):
+        """تشغيل وحدة إدارة المشاريع"""
+        # إنشاء قائمة العناصر
+        menu_items = [
+            {"name": "لوحة المعلومات", "icon": "house"},
+            {"name": "المناقصات والعقود", "icon": "file-text"},
+            {"name": "تحليل المستندات", "icon": "file-earmark-text"},
+            {"name": "نظام التسعير", "icon": "calculator"},
+            {"name": "حاسبة تكاليف البناء", "icon": "building"},
+            {"name": "الموارد والتكاليف", "icon": "people"},
+            {"name": "تحليل المخاطر", "icon": "exclamation-triangle"},
+            {"name": "إدارة المشاريع", "icon": "kanban"},
+            {"name": "الخرائط والمواقع", "icon": "geo-alt"},
+            {"name": "الجدول الزمني", "icon": "calendar3"},
+            {"name": "الإشعارات", "icon": "bell"},
+            {"name": "مقارنة المستندات", "icon": "files"},
+            {"name": "الترجمة", "icon": "translate"},
+            {"name": "المساعد الذكي", "icon": "robot"},
+            {"name": "التقارير", "icon": "bar-chart"},
+            {"name": "الإعدادات", "icon": "gear"}
+        ]
+        
+        # إنشاء الشريط الجانبي
+        selected = self.ui.create_sidebar(menu_items)
+        
+        # إنشاء ترويسة الصفحة
+        self.ui.create_header("إدارة المشاريع", "إدارة ومتابعة المشاريع والمناقصات")
+        
+        # عرض واجهة وحدة إدارة المشاريع
+        tabs = st.tabs([
+            "قائمة المشاريع",
+            "إضافة مشروع جديد",
+            "تفاصيل المشروع",
+            "متابعة المشاريع"
+        ])
+        
+        with tabs[0]:
+            self._render_projects_list_tab()
+        
+        with tabs[1]:
+            self._render_add_project_tab()
+        
+        with tabs[2]:
+            self._render_project_details_tab()
+        
+        with tabs[3]:
+            self._render_projects_tracking_tab()
+    
+    def _render_projects_list_tab(self):
+        """عرض تبويب قائمة المشاريع"""
+        
+        st.markdown("### قائمة المشاريع")
+        
+        # فلترة المشاريع
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            search_term = st.text_input("البحث في المشاريع", key="project_search")
+        
+        with col2:
+            status_filter = st.multiselect(
+                "حالة المشروع",
+                ["جديد", "قيد التسعير", "تم التقديم", "تمت الترسية", "قيد التنفيذ", "منتهي", "ملغي"],
+                default=["جديد", "قيد التسعير", "تم التقديم"],
+                key="project_status_filter"
+            )
+        
+        with col3:
+            client_filter = st.multiselect(
+                "الجهة المالكة",
+                list(set([p['client'] for p in st.session_state.projects])),
+                key="project_client_filter"
+            )
+        
+        # تطبيق الفلترة
+        filtered_projects = st.session_state.projects
+        
+        if search_term:
+            filtered_projects = [p for p in filtered_projects if search_term.lower() in p['name'].lower() or search_term in p['number']]
+        
+        if status_filter:
+            filtered_projects = [p for p in filtered_projects if p['status'] in status_filter]
+        
+        if client_filter:
+            filtered_projects = [p for p in filtered_projects if p['client'] in client_filter]
+        
+        # تحويل المشاريع المفلترة إلى DataFrame للعرض
+        if filtered_projects:
+            projects_df = pd.DataFrame(filtered_projects)
+            
+            # اختيار وتر��يب الأعمدة
+            display_columns = [
+                'name', 'number', 'client', 'location', 'status',
+                'submission_date', 'tender_type', 'created_at'
+            ]
+            
+            # تغيير أسماء الأعمدة للعرض
+            column_names = {
+                'name': 'اسم المشروع',
+                'number': 'رقم المناقصة',
+                'client': 'الجهة المالكة',
+                'location': 'الموقع',
+                'status': 'الحالة',
+                'submission_date': 'تاريخ التقديم',
+                'tender_type': 'نوع المناقصة',
+                'created_at': 'تاريخ الإنشاء'
+            }
+            
+            display_df = projects_df[display_columns].rename(columns=column_names)
+            
+            # تنسيق التواريخ
+            date_columns = ['تاريخ التقديم', 'تاريخ الإنشاء']
+            for col in date_columns:
+                if col in display_df.columns:
+                    display_df[col] = pd.to_datetime(display_df[col]).dt.strftime('%Y-%m-%d')
+            
+            # عرض الجدول
+            st.dataframe(display_df, use_container_width=True, hide_index=True)
+            
+            # زر تصدير المشاريع
+            if st.button("تصدير المشاريع إلى Excel"):
+                # محاكاة التصدير
+                st.success("تم تصدير المشاريع بنجاح!")
+        else:
+            st.info("لا توجد مشاريع تطابق معايير البحث.")
+    
+    def _render_add_project_tab(self):
+        """عرض تبويب إضافة مشروع جديد"""
+        
+        st.markdown("### إضافة مشروع جديد")
+        
+        # نموذج إدخال بيانات المشروع
+        with st.form("new_project_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                project_name = st.text_input("اسم المشروع", key="new_project_name")
+                client = st.text_input("الجهة المالكة", key="new_project_client")
+                location = st.text_input("الموقع", key="new_project_location")
+                tender_type = st.selectbox(
+                    "نوع المناقصة",
+                    ["عامة", "خاصة", "أمر مباشر"],
+                    key="new_project_tender_type"
+                )
+            
+            with col2:
+                tender_number = st.text_input("رقم المناقصة", key="new_project_number")
+                submission_date = st.date_input("تاريخ التقديم", key="new_project_submission_date")
+                pricing_method = st.selectbox(
+                    "طريقة التسعير",
+                    ["قياسي", "غير متزن", "تنافسي", "موجه بالربحية"],
+                    key="new_project_pricing_method"
+                )
+                status = st.selectbox(
+                    "حالة المشروع",
+                    ["جديد", "قيد التسعير", "تم التقديم", "تمت الترسية", "قيد التنفيذ", "منتهي", "ملغي"],
+                    index=0,
+                    key="new_project_status"
+                )
+            
+            description = st.text_area("وصف المشروع", key="new_project_description")
+            
+            submitted = st.form_submit_button("إضافة المشروع")
+            
+            if submitted:
+                # التحقق من تعبئة الحقول الإلزامية
+                if not project_name or not tender_number or not client:
+                    st.error("يرجى تعبئة جميع الحقول الإلزامية (اسم المشروع، رقم المناقصة، الجهة المالكة).")
+                else:
+                    # إنشاء مشروع جديد
+                    new_project = {
+                        'id': len(st.session_state.projects) + 1,
+                        'name': project_name,
+                        'number': tender_number,
+                        'client': client,
+                        'location': location,
+                        'description': description,
+                        'status': status,
+                        'tender_type': tender_type,
+                        'pricing_method': pricing_method,
+                        'submission_date': submission_date,
+                        'created_at': datetime.now(),
+                        'created_by_id': 1  # معرف المستخدم الحالي
+                    }
+                    
+                    # إضافة المشروع إلى قائمة المشاريع
+                    st.session_state.projects.append(new_project)
+                    
+                    # رسالة نجاح
+                    st.success(f"تم إضافة المشروع [{project_name}] بنجاح!")
+                    
+                    # تعيين المشروع الحالي
+                    st.session_state.current_project = new_project
+    
+    def _render_project_details_tab(self):
+        """عرض تبويب تفاصيل المشروع"""
+        
+        st.markdown("### تفاصيل المشروع")
+        
+        # التحقق من وجود مشروع حالي
+        if 'current_project' not in st.session_state or st.session_state.current_project is None:
+            # إذا لم يكن هناك مشروع محدد، اعرض قائمة باختيار المشروع
+            project_names = [p['name'] for p in st.session_state.projects]
+            selected_project_name = st.selectbox("اختر المشروع", project_names)
+            
+            if selected_project_name:
+                selected_project = next((p for p in st.session_state.projects if p['name'] == selected_project_name), None)
+                if selected_project:
+                    st.session_state.current_project = selected_project
+                else:
+                    st.warning("لم يتم العثور على المشروع المحدد.")
+                    return
+            else:
+                st.info("يرجى اختيار مشروع لعرض تفاصيله.")
+                return
+        
+        # عرض تفاصيل المشروع
+        project = st.session_state.current_project
+        
+        # عرض معلومات المشروع الأساسية
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.markdown(f"**اسم المشروع**: {project['name']}")
+            st.markdown(f"**رقم المناقصة**: {project['number']}")
+            st.markdown(f"**الجهة المالكة**: {project['client']}")
+        
+        with col2:
+            st.markdown(f"**الموقع**: {project['location']}")
+            st.markdown(f"**نوع المناقصة**: {project['tender_type']}")
+            st.markdown(f"**حالة المشروع**: {project['status']}")
+        
+        with col3:
+            st.markdown(f"**طريقة التسعير**: {project['pricing_method']}")
+            st.markdown(f"**تاريخ التقديم**: {project['submission_date'].strftime('%Y-%m-%d') if isinstance(project['submission_date'], datetime) else project['submission_date']}")
+            st.markdown(f"**تاريخ الإنشاء**: {project['created_at'].strftime('%Y-%m-%d') if isinstance(project['created_at'], datetime) else project['created_at']}")
+        
+        # عرض وصف المشروع
+        st.markdown("#### وصف المشروع")
+        st.text_area("", value=project.get('description', ''), disabled=True, height=100)
+        
+        # عرض المستندات المرتبطة بالمشروع
+        st.markdown("#### مستندات المشروع")
+        
+        if 'documents' in project and project['documents']:
+            docs_df = pd.DataFrame(project['documents'])
+            st.dataframe(docs_df, use_container_width=True, hide_index=True)
+        else:
+            st.info("لا توجد مستندات مرتبطة بهذا المشروع حاليًا.")
+            
+            # زر إضافة مستندات
+            if st.button("إضافة مستندات"):
+                st.session_state.upload_documents = True
+        
+        # واجهة تحميل المستندات
+        if 'upload_documents' in st.session_state and st.session_state.upload_documents:
+            st.markdown("#### تحميل مستندات جديدة")
+            
+            uploaded_file = st.file_uploader("اختر ملفًا", type=['pdf', 'docx', 'xlsx', 'png', 'jpg', 'dwg'])
+            doc_type = st.selectbox("نوع المستند", ["كراسة شروط", "عقد", "مخططات", "جدول كميات", "مواصفات فنية", "تعديلات وملاحق"])
+            
+            if uploaded_file and st.button("تحميل المستند"):
+                # محاكاة تحميل المستند
+                with st.spinner("جاري تحميل المستند..."):
+                    time.sleep(2)
+                    
+                    # إنشاء مستند جديد
+                    new_document = {
+                        'filename': uploaded_file.name,
+                        'type': doc_type,
+                        'upload_date': datetime.now().strftime('%Y-%m-%d'),
+                        'size': f"{uploaded_file.size / 1024:.1f} KB"
+                    }
+                    
+                    # إضافة المستند إلى المشروع
+                    if 'documents' not in project:
+                        project['documents'] = []
+                    
+                    project['documents'].append(new_document)
+                    
+                    st.success(f"تم تحميل المستند [{uploaded_file.name}] بنجاح!")
+                    st.session_state.upload_documents = False
+                    st.experimental_rerun()
+        
+        # عرض البنود والكميات
+        st.markdown("#### بنود وكميات المشروع")
+        
+        if 'items' in project and project['items']:
+            items_df = pd.DataFrame(project['items'])
+            st.dataframe(items_df, use_container_width=True, hide_index=True)
+            
+            # زر لتحويل البنود إلى وحدة التسعير
+            if st.button("تحويل البنود إلى وحدة التسعير"):
+                if 'manual_items' not in st.session_state:
+                    st.session_state.manual_items = pd.DataFrame()
+                
+                st.session_state.manual_items = items_df.copy()
+                st.success("تم تحويل البنود إلى وحدة التسعير بنجاح!")
+        else:
+            st.info("لا توجد بنود وكميات لهذا المشروع حاليًا.")
+            
+            # زر استيراد البنود من وحدة تحليل المستندات
+            if st.button("استيراد البنود من تحليل المستندات"):
+                st.warning("ميزة استيراد البنود من تحليل المستندات قيد التطوير.")
+        
+        # أزرار الإجراءات
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            if st.button("تعديل المشروع"):
+                st.session_state.edit_project = True
+                st.experimental_rerun()
+        
+        with col2:
+            if st.button("تصدير بيانات المشروع"):
+                st.success("تم تصدير بيانات المشروع بنجاح!")
+        
+        with col3:
+            if st.button("إرسال للاعتماد"):
+                st.success("تم إرسال المشروع للاعتماد بنجاح!")
+        
+        # نموذج تعديل المشروع
+        if 'edit_project' in st.session_state and st.session_state.edit_project:
+            st.markdown("#### تعديل المشروع")
+            
+            with st.form("edit_project_form"):
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    project_name = st.text_input("اسم المشروع", value=project['name'])
+                    client = st.text_input("الجهة المالكة", value=project['client'])
+                    location = st.text_input("الموقع", value=project['location'])
+                    tender_type = st.selectbox(
+                        "نوع المناقصة",
+                        ["عامة", "خاصة", "أمر مباشر"],
+                        index=["عامة", "خاصة", "أمر مباشر"].index(project['tender_type'])
+                    )
+                
+                with col2:
+                    tender_number = st.text_input("رقم المناقصة", value=project['number'])
+                    submission_date = st.date_input(
+                        "تاريخ التقديم",
+                        value=datetime.strptime(project['submission_date'], "%Y-%m-%d") if isinstance(project['submission_date'], str) else project['submission_date']
+                    )
+                    pricing_method = st.selectbox(
+                        "طريقة التسعير",
+                        ["قياسي", "غير متزن", "تنافسي", "موجه بالربحية"],
+                        index=["قياسي", "غير متزن", "تنافسي", "موجه بالربحية"].index(project['pricing_method'])
+                    )
+                    status = st.selectbox(
+                        "حالة المشروع",
+                        ["جديد", "قيد التسعير", "تم التقديم", "تمت الترسية", "قيد التنفيذ", "منتهي", "ملغي"],
+                        index=["جديد", "قيد التسعير", "تم التقديم", "تمت الترسية", "قيد التنفيذ", "منتهي", "ملغي"].index(project['status'])
+                    )
+                
+                description = st.text_area("وصف المشروع", value=project.get('description', ''))
+                
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    submit = st.form_submit_button("حفظ التعديلات")
+                
+                with col2:
+                    cancel = st.form_submit_button("إلغاء")
+                
+                if submit:
+                    # تحديث بيانات المشروع
+                    project['name'] = project_name
+                    project['number'] = tender_number
+                    project['client'] = client
+                    project['location'] = location
+                    project['description'] = description
+                    project['status'] = status
+                    project['tender_type'] = tender_type
+                    project['pricing_method'] = pricing_method
+                    project['submission_date'] = submission_date
+                    
+                    st.success("تم تحديث بيانات المشروع بنجاح!")
+                    st.session_state.edit_project = False
+                    st.experimental_rerun()
+                
+                elif cancel:
+                    st.session_state.edit_project = False
+                    st.experimental_rerun()
+    
+    def _render_projects_tracking_tab(self):
+        """عرض تبويب متابعة المشاريع"""
+        
+        st.markdown("### متابعة المشاريع")
+        
+        # عرض إحصائيات المشاريع
+        col1, col2, col3, col4 = st.columns(4)
+        
+        projects = st.session_state.projects
+        
+        with col1:
+            total_projects = len(projects)
+            self.ui.create_metric_card("إجمالي المشاريع", str(total_projects), None, self.ui.COLORS['primary'])
+        
+        with col2:
+            active_projects = len([p for p in projects if p['status'] in ["قيد التسعير", "تم التقديم", "تمت الترسية", "قيد التنفيذ"]])
+            self.ui.create_metric_card("المشاريع النشطة", str(active_projects), None, self.ui.COLORS['success'])
+        
+        with col3:
+            pending_submission = len([p for p in projects if p['status'] in ["جديد", "قيد التسعير"]])
+            self.ui.create_metric_card("مشاريع قيد التسعير", str(pending_submission), None, self.ui.COLORS['warning'])
+        
+        with col4:
+            completed_projects = len([p for p in projects if p['status'] in ["منتهي"]])
+            self.ui.create_metric_card("المشاريع المنتهية", str(completed_projects), None, self.ui.COLORS['info'])
+        
+        # عرض رسم بياني لحالة المشاريع
+        st.markdown("#### توزيع المشاريع حسب الحالة")
+        
+        status_counts = {}
+        for p in projects:
+            status = p['status']
+            status_counts[status] = status_counts.get(status, 0) + 1
+        
+        status_df = pd.DataFrame({
+            'الحالة': list(status_counts.keys()),
+            'عدد المشاريع': list(status_counts.values())
+        })
+        
+        st.bar_chart(status_df.set_index('الحالة'))
+        
+        # عرض المشاريع قيد المتابعة
+        st.markdown("#### المشاريع قيد المتابعة")
+        
+        # عرض المشاريع النشطة المرتبة حسب تاريخ التقديم
+        active_projects_list = [p for p in projects if p['status'] in ["قيد التسعير", "تم التقديم", "تمت الترسية", "قيد التنفيذ"]]
+        
+        if active_projects_list:
+            # تحويل التواريخ إلى كائنات تاريخ إذا كانت نصوصًا
+            for p in active_projects_list:
+                if isinstance(p['submission_date'], str):
+                    p['submission_date'] = datetime.strptime(p['submission_date'], "%Y-%m-%d")
+            
+            # ترتيب المشاريع حسب تاريخ التقديم
+            active_projects_list.sort(key=lambda x: x['submission_date'])
+            
+            # تحويل إلى DataFrame
+            active_df = pd.DataFrame(active_projects_list)
+            
+            # اختيار وترتيب الأعمدة
+            display_columns = [
+                'name', 'number', 'client', 'status',
+                'submission_date', 'tender_type'
+            ]
+            
+            # تغيير أسماء الأعمدة
+            column_names = {
+                'name': 'اسم المشروع',
+                'number': 'رقم المناقصة',
+                'client': 'الجهة المالكة',
+                'status': 'الحالة',
+                'submission_date': 'تاريخ التقديم',
+                'tender_type': 'نوع المناقصة'
+            }
+            
+            # تنسيق البيانات
+            display_df = active_df[display_columns].rename(columns=column_names)
+            display_df['تاريخ التقديم'] = pd.to_datetime(display_df['تاريخ التقديم']).dt.strftime('%Y-%m-%d')
+            
+            # عرض الجدول
+            st.dataframe(display_df, use_container_width=True, hide_index=True)
+        else:
+            st.info("لا توجد مشاريع نشطة حاليًا.")
+        
+        # عرض المشاريع المقبلة
+        st.markdown("#### المواعيد المقبلة")
+        
+        upcoming_events = []
+        today = datetime.now().date()
+        
+        for p in projects:
+            submission_date = p['submission_date']
+            if isinstance(submission_date, str):
+                submission_date = datetime.strptime(submission_date, "%Y-%m-%d").date()
+            elif isinstance(submission_date, datetime):
+                submission_date = submission_date.date()
+            
+            # المشاريع التي موعد تقديمها خلال الأسبوعين القادمين
+            if today <= submission_date <= today + timedelta(days=14) and p['status'] in ["قيد التسعير"]:
+                days_left = (submission_date - today).days
+                upcoming_events.append({
+                    'المشروع': p['name'],
+                    'الحدث': 'موعد تقديم المناقصة',
+                    'التاريخ': submission_date.strftime('%Y-%m-%d'),
+                    'الأيام المتبقية': days_left
+                })
+        
+        if upcoming_events:
+            events_df = pd.DataFrame(upcoming_events)
+            st.dataframe(events_df, use_container_width=True, hide_index=True)
+        else:
+            st.info("لا توجد مواعيد قريبة.")
+    
+    def _generate_sample_projects(self):
+        """توليد بيانات افتراضية للمشاريع"""
+        
+        projects = [
+            {
+                'id': 1,
+                'name': "إنشاء مبنى مستشفى الولادة والأطفال بمنطقة الشرقية",
+                'number': "SHPD-2025-001",
+                'client': "وزارة الصحة",
+                'location': "الدمام، المنطقة الشرقية",
+                'description': "يشمل المشروع إنشاء وتجهيز مبنى مستشفى الولادة والأطفال بسعة 300 سرير، ويتكون المبنى من 4 طوابق بمساحة إجمالية 15,000 متر مربع.",
+                'status': "قيد التسعير",
+                'tender_type': "عامة",
+                'pricing_method': "قياسي",
+                'submission_date': (datetime.now() + timedelta(days=5)),
+                'created_at': datetime.now() - timedelta(days=10),
+                'created_by_id': 1,
+                'documents': [
+                    {
+                        'filename': "كراسة الشروط والمواصفات.pdf",
+                        'type': "كراسة شروط",
+                        'upload_date': (datetime.now() - timedelta(days=9)).strftime('%Y-%m-%d'),
+                        'size': "5.2 MB"
+                    },
+                    {
+                        'filename': "المخططات الهندسية.dwg",
+                        'type': "مخططات",
+                        'upload_date': (datetime.now() - timedelta(days=8)).strftime('%Y-%m-%d'),
+                        'size': "25.7 MB"
+                    },
+                    {
+                        'filename': "جدول الكميات.xlsx",
+                        'type': "جدول كميات",
+                        'upload_date': (datetime.now() - timedelta(days=7)).strftime('%Y-%m-%d'),
+                        'size': "1.8 MB"
+                    }
+                ],
+                'items': [
+                    {
+                        'رقم البند': "A1",
+                        'وصف البند': "أعمال الحفر والردم",
+                        'الوحدة': "م3",
+                        'الكمية': 12500
+                    },
+                    {
+                        'رقم البند': "A2",
+                        'وصف البند': "أعمال الخرسانة المسلحة للأساسات",
+                        'الوحدة': "م3",
+                        'الكمية': 3500
+                    },
+                    {
+                        'رقم البند': "A3",
+                        'وصف البند': "أعمال حديد التسليح",
+                        'الوحدة': "طن",
+                        'الكمية': 450
+                    }
+                ]
+            },
+            {
+                'id': 2,
+                'name': "صيانة وتطوير طريق الملك عبدالله",
+                'number': "MOT-2025-042",
+                'client': "وزارة النقل",
+                'location': "الرياض، المنطقة الوسطى",
+                'description': "صيانة وتطوير طريق الملك عبدالله بطول 25 كم، ويشمل المشروع إعادة الرصف وتحسين الإنارة وتركيب اللوحات الإرشادية.",
+                'status': "تم التقديم",
+                'tender_type': "عامة",
+                'pricing_method': "غير متزن",
+                'submission_date': (datetime.now() - timedelta(days=15)),
+                'created_at': datetime.now() - timedelta(days=45),
+                'created_by_id': 1
+            },
+            {
+                'id': 3,
+                'name': "إنشاء محطة معالجة مياه الصرف الصحي",
+                'number': "SWPC-2025-007",
+                'client': "شركة المياه الوطنية",
+                'location': "جدة، المنطقة الغربية",
+                'description': "إنشاء محطة معالجة مياه الصرف الصحي بطاقة استيعابية 50,000 م3/يوم، مع جميع الأعمال المدنية والكهروميكانيكية.",
+                'status': "تمت الترسية",
+                'tender_type': "عامة",
+                'pricing_method': "قياسي",
+                'submission_date': (datetime.now() - timedelta(days=90)),
+                'created_at': datetime.now() - timedelta(days=120),
+                'created_by_id': 1
+            },
+            {
+                'id': 4,
+                'name': "إنشاء منتزه الملك سلمان",
+                'number': "RAM-2025-015",
+                'client': "أمانة منطقة الرياض",
+                'location': "الرياض، المنطقة الوسطى",
+                'description': "إنشاء منتزه الملك سلمان على مساحة 500,000 متر مربع، ويشمل المشروع أعمال التشجير والتنسيق والمسطحات المائية والمباني الخدمية.",
+                'status': "قيد التنفيذ",
+                'tender_type': "عامة",
+                'pricing_method': "قياسي",
+                'submission_date': (datetime.now() - timedelta(days=180)),
+                'created_at': datetime.now() - timedelta(days=210),
+                'created_by_id': 1
+            },
+            {
+                'id': 5,
+                'name': "إنشاء مبنى مختبرات كلية العلوم",
+                'number': "KSU-2025-032",
+                'client': "جامعة الملك سعود",
+                'location': "الرياض، المنطقة الوسطى",
+                'description': "إنشاء مبنى المختبرات الجديد لكلية العلوم بمساحة 8,000 متر مربع، ويتكون من 3 طوابق ويشمل تجهيز المعامل والمختبرات العلمية.",
+                'status': "جديد",
+                'tender_type': "خاصة",
+                'pricing_method': "تنافسي",
+                'submission_date': (datetime.now() + timedelta(days=10)),
+                'created_at': datetime.now() - timedelta(days=5),
+                'created_by_id': 1
+            },
+            {
+                'id': 6,
+                'name': "توريد وتركيب أنظمة الطاقة الشمسية",
+                'number': "SEC-2025-098",
+                'client': "الشركة السعودية للكهرباء",
+                'location': "تبوك، المنطقة الشمالية",
+                'description': "توريد وتركيب أنظمة الطاقة الشمسية بقدرة 5 ميجاوات، مع جميع الأعمال المدنية والكهربائية.",
+                'status': "جديد",
+                'tender_type': "عامة",
+                'pricing_method': "قياسي",
+                'submission_date': (datetime.now() + timedelta(days=20)),
+                'created_at': datetime.now() - timedelta(days=2),
+                'created_by_id': 1
+            }
+        ]
+        
+        return projects
+
+# تشغيل التطبيق
+if __name__ == "__main__":
+    projects_app = ProjectsApp()
+    projects_app.run()

modules/reports/reports_app.py

@@ -0,0 +1,958 @@
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+from datetime import datetime, timedelta
+import time
+
+class ReportsApp:
+    """وحدة التقارير والتحليلات"""
+
+    def __init__(self):
+        """تهيئة وحدة التقارير والتحليلات"""
+        # تهيئة متغير السمة في حالة الجلسة إذا لم يكن موجوداً
+        if 'theme' not in st.session_state:
+            st.session_state.theme = 'light'
+
+    def run(self):
+        """
+        تشغيل وحدة التقارير والتحليلات
+        
+        هذه الدالة هي نقطة الدخول الرئيسية لوحدة التقارير والتحليلات.
+        تقوم بتهيئة واجهة المستخدم وعرض الوظائف المختلفة للتقارير والتحليلات.
+        """
+        try:
+            # تعيين عنوان الصفحة
+            st.set_page_config(
+                page_title="وحدة التقارير والتحليلات - نظام المناقصات",
+                page_icon="📊",
+                layout="wide",
+                initial_sidebar_state="expanded"
+            )
+            
+            # تطبيق التنسيق المخصص
+            st.markdown("""
+            <style>
+            .module-title {
+                color: #2c3e50;
+                text-align: center;
+                font-size: 2.5rem;
+                margin-bottom: 1rem;
+                padding-bottom: 1rem;
+                border-bottom: 2px solid #3498db;
+            }
+            .stTabs [data-baseweb="tab-list"] {
+                gap: 10px;
+            }
+            .stTabs [data-baseweb="tab"] {
+                height: 50px;
+                white-space: pre-wrap;
+                background-color: #f8f9fa;
+                border-radius: 4px 4px 0px 0px;
+                gap: 1px;
+                padding-top: 10px;
+                padding-bottom: 10px;
+            }
+            .stTabs [aria-selected="true"] {
+                background-color: #3498db;
+                color: white;
+            }
+            </style>
+            """, unsafe_allow_html=True)
+            
+            # إضافة زر تبديل السمة في أعلى الصفحة
+            col1, col2, col3 = st.columns([1, 8, 1])
+            with col3:
+                if st.button("🌓 تبديل السمة"):
+                    # تبديل السمة
+                    if st.session_state.theme == "light":
+                        st.session_state.theme = "dark"
+                    else:
+                        st.session_state.theme = "light"
+                    
+                    # تطبيق السمة الجديدة وإعادة تشغيل التطبيق
+                    st.rerun()
+            
+            # عرض الشريط الجانبي
+            with st.sidebar:
+                st.image("/home/ubuntu/tender_system/tender_system/assets/images/logo.png", width=200)
+                st.markdown("## نظام تحليل المناقصات")
+                st.markdown("### وحدة التقارير والتحليلات")
+                
+                st.markdown("---")
+                
+                # إضافة خيارات تصفية التقارير
+                st.markdown("### خيارات التصفية")
+                
+                # تصفية حسب الفترة الزمنية
+                date_range = st.selectbox(
+                    "الفترة الزمنية",
+                    ["آخر 7 أيام", "آخر 30 يوم", "آخر 90 يوم", "آخر 365 يوم", "كل الفترات"]
+                )
+                
+                # تصفية حسب نوع المشروع
+                project_type = st.multiselect(
+                    "نوع المشروع",
+                    ["مباني", "طرق", "جسور", "أنفاق", "بنية تحتية", "أخرى"],
+                    default=["مباني", "طرق", "جسور", "أنفاق", "بنية تحتية", "أخرى"]
+                )
+                
+                # تصفية حسب حالة المشروع
+                project_status = st.multiselect(
+                    "حالة المشروع",
+                    ["جديد", "قيد التقديم", "تم التقديم", "فائز", "خاسر", "ملغي"],
+                    default=["جديد", "قيد التقديم", "تم التقديم", "فائز", "خاسر"]
+                )
+                
+                # زر تطبيق التصفية
+                if st.button("تطبيق التصفية"):
+                    st.success("تم تطبيق التصفية بنجاح!")
+                
+                st.markdown("---")
+                
+                # إضافة معلومات المستخدم
+                st.markdown("### معلومات المستخدم")
+                st.markdown("**المستخدم:** مهندس تامر الجوهري")
+                st.markdown("**الدور:** محلل مناقصات")
+                st.markdown("**تاريخ آخر دخول:** " + datetime.now().strftime("%Y-%m-%d %H:%M"))
+            
+            # عرض واجهة وحدة التقارير والتحليلات
+            self.render()
+            
+            # إضافة معلومات في أسفل الصفحة
+            st.markdown("---")
+            st.markdown("### نظام تحليل المناقصات - وحدة التقارير والتحليلات")
+            st.markdown("**الإصدار:** 2.0.0")
+            st.markdown("**تاريخ التحديث:** 2025-03-31")
+            st.markdown("**جميع الحقوق محفوظة © 2025**")
+            
+            return True
+            
+        except Exception as e:
+            st.error(f"حدث خطأ أثناء تشغيل وحدة التقارير والتحليلات: {str(e)}")
+            return False
+
+    def render(self):
+        """عرض واجهة وحدة التقارير والتحليلات"""
+        
+        st.markdown("<h1 class='module-title'>وحدة التقارير والتحليلات</h1>", unsafe_allow_html=True)
+        
+        tabs = st.tabs(["لوحة المعلومات", "تقارير المشاريع", "تقارير التسعير", "تقارير المخاطر", "التقارير المخصصة"])
+        
+        with tabs[0]:
+            self._render_dashboard_tab()
+        
+        with tabs[1]:
+            self._render_projects_reports_tab()
+        
+        with tabs[2]:
+            self._render_pricing_reports_tab()
+        
+        with tabs[3]:
+            self._render_risk_reports_tab()
+        
+        with tabs[4]:
+            self._render_custom_reports_tab()
+
+    def _render_dashboard_tab(self):
+        """عرض تبويب لوحة المعلومات"""
+        
+        st.markdown("### لوحة معلومات النظام")
+        
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            total_projects = self._get_total_projects()
+            st.metric("إجمالي المشاريع", total_projects)
+        
+        with col2:
+            active_projects = self._get_active_projects()
+            st.metric("المشاريع النشطة", active_projects, delta=f"{active_projects/total_projects*100:.1f}%" if total_projects > 0 else "0%")
+        
+        with col3:
+            won_projects = self._get_won_projects()
+            st.metric("المشاريع المرساة", won_projects, delta=f"{won_projects/total_projects*100:.1f}%" if total_projects > 0 else "0%")
+        
+        with col4:
+            avg_local_content = self._get_avg_local_content()
+            st.metric("متوسط المحتوى المحلي", f"{avg_local_content:.1f}%", delta=f"{avg_local_content-70:.1f}%" if avg_local_content > 0 else "0%")
+        
+        st.markdown("#### توزيع المشاريع حسب الحالة")
+        project_status_data = self._get_project_status_data()
+        fig = px.pie(project_status_data, values='count', names='status', title='توزيع المشاريع حسب الحالة', hole=0.4)
+        st.plotly_chart(fig, use_container_width=True)
+        
+        st.markdown("#### اتجاه المشاريع الشهري")
+        monthly_data = self._get_monthly_project_data()
+        fig = px.line(monthly_data, x='month', y=['new', 'submitted', 'won'], title='اتجاه المشاريع الشهري')
+        st.plotly_chart(fig, use_container_width=True)
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("#### توزيع المشاريع حسب النوع")
+            project_type_data = self._get_project_type_data()
+            fig = px.bar(project_type_data, x='type', y='count', title='توزيع المشاريع حسب النوع')
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            st.markdown("#### توزيع المشاريع حسب الموقع")
+            project_location_data = self._get_project_location_data()
+            fig = px.bar(project_location_data, x='location', y='count', title='توزيع المشاريع حسب الموقع')
+            st.plotly_chart(fig, use_container_width=True)
+        
+        st.markdown("#### أحدث المشاريع")
+        latest_projects = self._get_latest_projects()
+        st.dataframe(latest_projects)
+
+    def _render_projects_reports_tab(self):
+        """عرض تبويب تقارير المشاريع"""
+        
+        st.markdown("### تقارير المشاريع")
+        
+        report_type = st.selectbox(
+            "نوع التقرير",
+            ["تقرير حالة المشاريع", "تقرير أداء المشاريع", "تقرير المشاريع المتأخرة", "تقرير المشاريع المكتملة"]
+        )
+        
+        if report_type == "تقرير حالة المشاريع":
+            self._render_project_status_report()
+        elif report_type == "تقرير أداء المشاريع":
+            self._render_project_performance_report()
+        elif report_type == "تقرير المشاريع المتأخرة":
+            self._render_delayed_projects_report()
+        elif report_type == "تقرير المشاريع المكتملة":
+            self._render_completed_projects_report()
+
+    def _render_pricing_reports_tab(self):
+        """عرض تبويب تقارير التسعير"""
+        
+        st.markdown("### تقارير التسعير")
+        
+        report_type = st.selectbox(
+            "نوع التقرير",
+            ["تقرير تحليل الأسعار", "تقرير مقارنة الأسعار", "تقرير اتجاهات الأسعار", "تقرير تحليل المنافسين"]
+        )
+        
+        if report_type == "تقرير تحليل الأسعار":
+            self._render_price_analysis_report()
+        elif report_type == "تقرير مقارنة الأسعار":
+            self._render_price_comparison_report()
+        elif report_type == "تقرير اتجاهات الأسعار":
+            self._render_price_trends_report()
+        elif report_type == "تقرير تحليل المنافسين":
+            self._render_competitors_analysis_report()
+
+    def _render_risk_reports_tab(self):
+        """عرض تبويب تقارير المخاطر"""
+        
+        st.markdown("### تقارير المخاطر")
+        
+        report_type = st.selectbox(
+            "نوع التقرير",
+            ["تقرير تحليل المخاطر", "تقرير مصفوفة المخاطر", "تقرير متابعة المخاطر", "تقرير استراتيجيات التخفيف"]
+        )
+        
+        if report_type == "تقرير تحليل المخاطر":
+            self._render_risk_analysis_report()
+        elif report_type == "تقرير مصفوفة المخاطر":
+            self._render_risk_matrix_report()
+        elif report_type == "تقرير متابعة المخاطر":
+            self._render_risk_monitoring_report()
+        elif report_type == "تقرير استراتيجيات التخفيف":
+            self._render_risk_mitigation_report()
+
+    def _render_custom_reports_tab(self):
+        """عرض تبويب التقارير المخصصة"""
+        
+        st.markdown("### التقارير المخصصة")
+        
+        st.markdown("#### إنشاء تقرير مخصص")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            report_name = st.text_input("اسم التقرير")
+            report_description = st.text_area("وصف التقرير")
+        
+        with col2:
+            report_fields = st.multiselect(
+                "حقول التقرير",
+                ["رقم المشروع", "اسم المشروع", "نوع المشروع", "حالة المشروع", "تاريخ البدء", "تاريخ الانتهاء", "الميزانية", "التكلفة الفعلية", "نسبة الإنجاز", "المخاطر", "الموقع", "المالك", "المقاول"]
+            )
+            
+            report_filters = st.multiselect(
+                "تصفية التقرير",
+                ["نوع المشروع", "حالة المشروع", "الفترة الزمنية", "الميزانية", "الموقع", "المالك", "المقاول"]
+            )
+        
+        if st.button("إنشاء التقرير"):
+            if report_name and report_description and report_fields:
+                with st.spinner("جاري إنشاء التقرير..."):
+                    time.sleep(2)  # محاكاة وقت المعالجة
+                    st.success("تم إنشاء التقرير بنجاح!")
+                    
+                    # عرض التقرير المخصص (محاكاة)
+                    custom_report_data = self._generate_custom_report(report_fields)
+                    st.dataframe(custom_report_data)
+                    
+                    # تصدير التقرير
+                    st.download_button(
+                        label="تصدير التقرير (Excel)",
+                        data=self._export_to_excel(custom_report_data),
+                        file_name=f"{report_name}.xlsx",
+                        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                    )
+            else:
+                st.warning("يرجى ملء جميع الحقول المطلوبة")
+        
+        st.markdown("#### التقارير المخصصة المحفوظة")
+        
+        saved_reports = [
+            {"id": 1, "name": "تقرير المشاريع المتأخرة في الرياض", "created_at": "2025-03-15", "last_run": "2025-03-30"},
+            {"id": 2, "name": "تقرير مشاريع الطرق ذات المخاطر العالية", "created_at": "2025-03-10", "last_run": "2025-03-28"},
+            {"id": 3, "name": "تقر��ر المشاريع المكتملة في الربع الأول", "created_at": "2025-03-05", "last_run": "2025-03-25"}
+        ]
+        
+        saved_reports_df = pd.DataFrame(saved_reports)
+        st.dataframe(saved_reports_df)
+
+    # تنفيذ دوال الحصول على البيانات
+    
+    def _get_total_projects(self):
+        """الحصول على إجمالي عدد المشاريع"""
+        # محاكاة البيانات
+        return 120
+    
+    def _get_active_projects(self):
+        """الحصول على عدد المشاريع النشطة"""
+        # محاكاة البيانات
+        return 45
+    
+    def _get_won_projects(self):
+        """الحصول على عدد المشاريع المرساة"""
+        # محاكاة البيانات
+        return 30
+    
+    def _get_avg_local_content(self):
+        """الحصول على متوسط المحتوى المحلي"""
+        # محاكاة البيانات
+        return 75.5
+    
+    def _get_project_status_data(self):
+        """الحصول على بيانات توزيع المشاريع حسب الحالة"""
+        # محاكاة البيانات
+        data = {
+            'status': ['جديد', 'قيد التقديم', 'تم التقديم', 'فائز', 'خاسر', 'ملغي'],
+            'count': [25, 20, 15, 30, 25, 5]
+        }
+        return pd.DataFrame(data)
+    
+    def _get_monthly_project_data(self):
+        """الحصول على بيانات اتجاه المشاريع الشهري"""
+        # محاكاة البيانات
+        data = {
+            'month': ['يناير', 'فبراير', 'مارس', 'أبريل', 'مايو', 'يونيو'],
+            'new': [10, 15, 12, 8, 20, 18],
+            'submitted': [8, 12, 10, 6, 15, 14],
+            'won': [5, 8, 6, 4, 10, 9]
+        }
+        return pd.DataFrame(data)
+    
+    def _get_project_type_data(self):
+        """الحصول على بيانات توزيع المشاريع حسب النوع"""
+        # محاكاة البيانات
+        data = {
+            'type': ['مباني', 'طرق', 'جسور', 'أنفاق', 'بنية تحتية', 'أخرى'],
+            'count': [40, 30, 15, 10, 20, 5]
+        }
+        return pd.DataFrame(data)
+    
+    def _get_project_location_data(self):
+        """الحصول على بيانات توزيع المشاريع حسب الموقع"""
+        # محاكاة البيانات
+        data = {
+            'location': ['الرياض', 'جدة', 'الدمام', 'مكة', 'المدينة', 'أخرى'],
+            'count': [35, 25, 20, 15, 10, 15]
+        }
+        return pd.DataFrame(data)
+    
+    def _get_latest_projects(self):
+        """الحصول على بيانات أحدث المشاريع"""
+        # محاكاة البيانات
+        data = {
+            'رقم المشروع': ['P-2025-001', 'P-2025-002', 'P-2025-003', 'P-2025-004', 'P-2025-005'],
+            'اسم المشروع': ['إنشاء مبنى إداري', 'تطوير شبكة طرق', 'إنشاء جسر', 'بناء مدرسة', 'تطوير شبكة مياه'],
+            'نوع المشروع': ['مباني', 'طرق', 'جسور', 'مباني', 'بنية تحتية'],
+            'حالة المشروع': ['جديد', 'قيد التقديم', 'تم التقديم', 'فائز', 'جديد'],
+            'تاريخ الإضافة': ['2025-03-30', '2025-03-28', '2025-03-25', '2025-03-20', '2025-03-18']
+        }
+        return pd.DataFrame(data)
+    
+    # تنفيذ دوال عرض التقارير
+    
+    def _render_project_status_report(self):
+        """عرض تقرير حالة المشاريع"""
+        
+        st.markdown("#### تقرير حالة المشاريع")
+        
+        # محاكاة بيانات التقرير
+        data = {
+            'رقم المشروع': ['P-2025-001', 'P-2025-002', 'P-2025-003', 'P-2025-004', 'P-2025-005', 'P-2025-006', 'P-2025-007', 'P-2025-008', 'P-2025-009', 'P-2025-010'],
+            'اسم المشروع': ['إنشاء مبنى إداري', 'تطوير شبكة طرق', 'إنشاء جسر', 'بناء مدرسة', 'تطوير شبكة مياه', 'إنشاء مستشفى', 'بناء مركز تجاري', 'تطوير حديقة عامة', 'إنشاء مصنع', 'تطوير مطار'],
+            'نوع المشروع': ['مباني', 'طرق', 'جسور', 'مباني', 'بنية تحتية', 'مباني', 'مباني', 'أخرى', 'مباني', 'بنية تحتية'],
+            'حالة المشروع': ['جديد', 'قيد التقديم', 'تم التقديم', 'فائز', 'جديد', 'فائز', 'خاسر', 'قيد التقديم', 'تم التقديم', 'فائز'],
+            'تاريخ البدء': ['2025-04-15', '2025-05-01', '2025-04-10', '2025-03-15', '2025-05-10', '2025-02-20', '2025-03-10', '2025-04-20', '2025-05-15', '2025-01-10'],
+            'تاريخ الانتهاء المتوقع': ['2026-04-15', '2026-05-01', '2026-04-10', '2025-12-15', '2026-05-10', '2026-02-20', '2025-12-10', '2025-10-20', '2026-05-15', '2026-07-10'],
+            'نسبة الإنجاز': ['0%', '10%', '5%', '25%', '0%', '30%', '0%', '15%', '5%', '40%']
+        }
+        
+        report_df = pd.DataFrame(data)
+        st.dataframe(report_df)
+        
+        # تصدير التقرير
+        st.download_button(
+            label="تصدير التقرير (Excel)",
+            data=self._export_to_excel(report_df),
+            file_name="تقرير_حالة_المشاريع.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+        
+        # عرض رسم بياني
+        status_counts = report_df['حالة المشروع'].value_counts().reset_index()
+        status_counts.columns = ['الحالة', 'العدد']
+        
+        fig = px.pie(status_counts, values='العدد', names='الحالة', title='توزيع المشاريع حسب الحالة')
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_project_performance_report(self):
+        """عرض تقرير أداء المشاريع"""
+        
+        st.markdown("#### تقرير أداء المشاريع")
+        
+        # محاكاة بيانات التقرير
+        data = {
+            'رقم المشروع': ['P-2024-001', 'P-2024-002', 'P-2024-003', 'P-2024-004', 'P-2024-005', 'P-2024-006', 'P-2024-007', 'P-2024-008'],
+            'اسم المشروع': ['إنشاء مبنى إداري', 'تطوير شبكة طرق', 'إنشاء جسر', 'بناء مدرسة', 'تطوير شبكة مياه', 'إنشاء مستشفى', 'بناء مركز تجاري', 'تطوير حديقة عامة'],
+            'نسبة الإنجاز المخططة': ['50%', '75%', '60%', '100%', '40%', '80%', '90%', '100%'],
+            'نسبة الإنجاز الفعلية': ['45%', '70%', '55%', '95%', '35%', '75%', '85%', '100%'],
+            'الميزانية المخططة': ['10,000,000', '15,000,000', '8,000,000', '5,000,000', '7,000,000', '20,000,000', '12,000,000', '3,000,000'],
+            'التكلفة الفعلية': ['9,500,000', '16,000,000', '8,200,000', '5,200,000', '7,500,000', '21,000,000', '12,500,000', '3,000,000'],
+            'مؤشر أداء الجدول الزمني': ['0.9', '0.93', '0.92', '0.95', '0.88', '0.94', '0.94', '1.0'],
+            'مؤشر أداء التكلفة': ['1.05', '0.94', '0.98', '0.96', '0.93', '0.95', '0.96', '1.0']
+        }
+        
+        report_df = pd.DataFrame(data)
+        st.dataframe(report_df)
+        
+        # تصدير التقرير
+        st.download_button(
+            label="تصدير التقرير (Excel)",
+            data=self._export_to_excel(report_df),
+            file_name="تقرير_أداء_المشاريع.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+        
+        # عرض رسم بياني
+        performance_data = {
+            'المشروع': data['اسم المشروع'],
+            'مؤشر أداء الجدول الزمني': [float(x) for x in data['مؤشر أداء الجدول الزمني']],
+            'مؤشر أداء التكلفة': [float(x) for x in data['مؤشر أداء التكلفة']]
+        }
+        
+        performance_df = pd.DataFrame(performance_data)
+        
+        fig = px.bar(performance_df, x='المشروع', y=['مؤشر أداء الجدول الزمني', 'مؤشر أداء التكلفة'], barmode='group', title='مؤشرات أداء المشاريع')
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_delayed_projects_report(self):
+        """عرض تقرير المشاريع المتأخرة"""
+        
+        st.markdown("#### تقرير المشاريع المتأخرة")
+        
+        # محاكاة بيانات التقرير
+        data = {
+            'رقم المشروع': ['P-2024-001', 'P-2024-002', 'P-2024-005', 'P-2024-006'],
+            'اسم المشروع': ['إنشاء مبنى إداري', 'تطوير شبكة طرق', 'تطوير شبكة مياه', 'إنشاء مستشفى'],
+            'نسبة الإنجاز المخططة': ['50%', '75%', '40%', '80%'],
+            'نسبة الإنجاز الفعلية': ['45%', '70%', '35%', '75%'],
+            'تاريخ البدء': ['2024-01-15', '2024-02-01', '2024-03-10', '2023-08-20'],
+            'تاريخ الانتهاء المخطط': ['2025-01-15', '2025-02-01', '2025-03-10', '2024-08-20'],
+            'التأخير (أيام)': ['15', '20', '10', '25'],
+            'سبب التأخير': ['تأخر التوريدات', 'ظروف جوية', 'نقص العمالة', 'تغيير نطاق العمل'],
+            'خطة التصحيح': ['زيادة الموارد', 'تعديل الجدول الزمني', 'توظيف عمالة إضافية', 'تعديل نطاق العمل']
+        }
+        
+        report_df = pd.DataFrame(data)
+        st.dataframe(report_df)
+        
+        # تصدير التقرير
+        st.download_button(
+            label="تصدير التقرير (Excel)",
+            data=self._export_to_excel(report_df),
+            file_name="تقرير_المشاريع_المتأخرة.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+        
+        # عرض رسم بياني
+        delay_data = {
+            'المشروع': data['اسم المشروع'],
+            'التأخير (أيام)': [int(x) for x in data['التأخير (أيام)']]
+        }
+        
+        delay_df = pd.DataFrame(delay_data)
+        
+        fig = px.bar(delay_df, x='المشروع', y='التأخير (أيام)', title='التأخير في المشاريع (أيام)')
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_completed_projects_report(self):
+        """عرض تقرير المشاريع المكتملة"""
+        
+        st.markdown("#### تقرير المشاريع المكتملة")
+        
+        # محاكاة بيانات التقرير
+        data = {
+            'رقم المشروع': ['P-2023-001', 'P-2023-002', 'P-2023-003', 'P-2023-004', 'P-2023-005'],
+            'اسم المشروع': ['إنشاء مبنى سكني', 'تطوير طريق سريع', 'بناء مدرسة', 'تطوير حديقة عامة', 'إنشاء مركز تجاري'],
+            'نوع المشروع': ['مباني', 'طرق', 'مباني', 'أخرى', 'مباني'],
+            'تاريخ البدء': ['2023-01-10', '2023-02-15', '2023-03-20', '2023-04-05', '2023-05-12'],
+            'تاريخ الانتهاء المخطط': ['2023-07-10', '2023-08-15', '2023-09-20', '2023-08-05', '2024-01-12'],
+            'تاريخ الانتهاء الفعلي': ['2023-07-25', '2023-09-10', '2023-09-15', '2023-08-01', '2024-01-20'],
+            'الميزانية المخططة': ['5,000,000', '8,000,000', '4,000,000', '2,000,000', '10,000,000'],
+            'التكلفة الفعلية': ['5,200,000', '8,500,000', '3,900,000', '1,950,000', '10,300,000'],
+            'تقييم الأداء': ['جيد', 'متوسط', 'ممتاز', 'ممتاز', 'جيد']
+        }
+        
+        report_df = pd.DataFrame(data)
+        st.dataframe(report_df)
+        
+        # تصدير التقرير
+        st.download_button(
+            label="تصدير التقرير (Excel)",
+            data=self._export_to_excel(report_df),
+            file_name="تقرير_المشاريع_المكتملة.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+        
+        # عرض رسم بياني
+        performance_counts = report_df['تقييم الأداء'].value_counts().reset_index()
+        performance_counts.columns = ['التقييم', 'العدد']
+        
+        fig = px.pie(performance_counts, values='العدد', names='التقييم', title='توزيع المشاريع حسب تقييم الأداء')
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_price_analysis_report(self):
+        """عرض تقرير تحليل الأسعار"""
+        
+        st.markdown("#### تقرير تحليل الأسعار")
+        
+        # محاكاة بيانات التقرير
+        data = {
+            'البند': ['أعمال الحفر', 'أعمال الخرسانة', 'أعمال التشطيبات', 'أعمال الكهرباء', 'أعمال السباكة', 'أعمال التكييف', 'أعمال الألمنيوم', 'أعمال الزجاج'],
+            'الوحدة': ['م³', 'م³', 'م²', 'نقطة', 'نقطة', 'طن تبريد', 'م²', 'م²'],
+            'متوسط السعر': ['50', '300', '100', '150', '120', '1,200', '350', '200'],
+            'أقل سعر': ['40', '250', '80', '120', '100', '1,000', '300', '180'],
+            'أعلى سعر': ['60', '350', '120', '180', '140', '1,400', '400', '220'],
+            'الانحراف المعياري': ['5', '25', '10', '15', '10', '100', '25', '10'],
+            'عدد العينات': ['15', '20', '25', '18', '18', '12', '15', '15']
+        }
+        
+        report_df = pd.DataFrame(data)
+        st.dataframe(report_df)
+        
+        # تصدير التقرير
+        st.download_button(
+            label="تصدير التقرير (Excel)",
+            data=self._export_to_excel(report_df),
+            file_name="تقرير_تحليل_الأسعار.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+        
+        # عرض رسم بياني
+        price_data = {
+            'البند': data['البند'],
+            'متوسط السعر': [float(x.replace(',', '')) for x in data['متوسط السعر']],
+            'أقل سعر': [float(x.replace(',', '')) for x in data['أقل سعر']],
+            'أعلى سعر': [float(x.replace(',', '')) for x in data['أعلى سعر']]
+        }
+        
+        price_df = pd.DataFrame(price_data)
+        
+        fig = px.bar(price_df, x='البند', y=['أقل سعر', 'متوسط السعر', 'أعلى سعر'], barmode='group', title='تحليل الأسعار حسب البند')
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_price_comparison_report(self):
+        """عرض تقرير مقارنة الأسعار"""
+        
+        st.markdown("#### تقرير مقارنة الأسعار")
+        
+        # محاكاة بيانات التقرير
+        data = {
+            'البند': ['أعمال الحفر', 'أعمال الخرسانة', 'أعمال التشطيبات', 'أعمال الكهرباء', 'أعمال السباكة', 'أعمال التكييف'],
+            'الوحدة': ['م³', 'م³', 'م²', 'نقطة', 'نقطة', 'طن تبريد'],
+            'سعرنا': ['50', '300', '100', '150', '120', '1,200'],
+            'سعر المنافس 1': ['55', '320', '110', '160', '130', '1,250'],
+            'سعر المنافس 2': ['48', '290', '95', '145', '115', '1,180'],
+            'سعر المنافس 3': ['52', '310', '105', '155', '125', '1,220'],
+            'متوسط السوق': ['51', '305', '103', '153', '123', '1,213'],
+            'الفرق عن متوسط السوق': ['-2%', '-2%', '-3%', '-2%', '-2%', '-1%']
+        }
+        
+        report_df = pd.DataFrame(data)
+        st.dataframe(report_df)
+        
+        # تصدير التقرير
+        st.download_button(
+            label="تصدير التقرير (Excel)",
+            data=self._export_to_excel(report_df),
+            file_name="تقرير_مقارنة_الأسعار.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+        
+        # عرض رسم بياني
+        comparison_data = {
+            'البند': data['البند'],
+            'سعرنا': [float(x.replace(',', '')) for x in data['سعرنا']],
+            'متوسط السوق': [float(x.replace(',', '')) for x in data['متوسط السوق']]
+        }
+        
+        comparison_df = pd.DataFrame(comparison_data)
+        
+        fig = px.bar(comparison_df, x='البند', y=['سعرنا', 'متوسط السوق'], barmode='group', title='مقارنة أسعارنا مع متوسط السوق')
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_price_trends_report(self):
+        """عرض تقرير اتجاهات الأسعار"""
+        
+        st.markdown("#### تقرير اتجاهات الأسعار")
+        
+        # محاكاة بيانات التقرير
+        materials = ['الخرسانة', 'الحديد', 'الأسمنت', 'الرمل', 'الطوب', 'الألمنيوم']
+        months = ['يناير', 'فبراير', 'مارس', 'أبريل', 'مايو', 'يونيو']
+        
+        # إنشاء بيانات الاتجاهات
+        trends_data = {'المادة': [], 'الشهر': [], 'السعر': []}
+        
+        for material in materials:
+            base_price = 100 + materials.index(material) * 50
+            for month in months:
+                month_factor = 1 + months.index(month) * 0.02
+                price = base_price * month_factor
+                
+                trends_data['المادة'].append(material)
+                trends_data['الشهر'].append(month)
+                trends_data['السعر'].append(round(price, 2))
+        
+        trends_df = pd.DataFrame(trends_data)
+        
+        # عرض البيانات في جدول
+        pivot_df = trends_df.pivot(index='المادة', columns='الشهر', values='السعر').reset_index()
+        st.dataframe(pivot_df)
+        
+        # تصدير التقرير
+        st.download_button(
+            label="تصدير التقرير (Excel)",
+            data=self._export_to_excel(pivot_df),
+            file_name="تقرير_اتجاهات_الأسعار.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+        
+        # عرض رسم بياني
+        fig = px.line(trends_df, x='الشهر', y='السعر', color='المادة', title='اتجاهات أسعار المواد')
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض نسبة التغير
+        st.markdown("#### نسبة التغير في الأسعار (يناير - يونيو)")
+        
+        change_data = {'المادة': [], 'نسبة التغير': []}
+        
+        for material in materials:
+            jan_price = trends_df[(trends_df['المادة'] == material) & (trends_df['الشهر'] == 'يناير')]['السعر'].values[0]
+            jun_price = trends_df[(trends_df['المادة'] == material) & (trends_df['الشهر'] == 'يونيو')]['السعر'].values[0]
+            change_pct = (jun_price - jan_price) / jan_price * 100
+            
+            change_data['المادة'].append(material)
+            change_data['نسبة التغير'].append(round(change_pct, 2))
+        
+        change_df = pd.DataFrame(change_data)
+        
+        fig = px.bar(change_df, x='المادة', y='نسبة التغير', title='نسبة التغير في أسعار المواد')
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_competitors_analysis_report(self):
+        """عرض تقرير تحليل المنافسين"""
+        
+        st.markdown("#### تقرير تحليل المنافسين")
+        
+        # محاكاة بيانات التقرير
+        data = {
+            'المنافس': ['شركة الإنشاءات المتطورة', 'شركة البناء الحديث', 'مؤسسة الإعمار', 'شركة التطوير العمراني', 'مجموعة الإنشاءات العربية'],
+            'عدد المشاريع الفائزة': ['15', '12', '8', '10', '7'],
+            'متوسط قيمة المشاريع': ['12,000,000', '8,000,000', '5,000,000', '10,000,000', '15,000,000'],
+            'نسبة الفوز': ['35%', '30%', '25%', '28%', '20%'],
+            'متوسط الخصم': ['5%', '8%', '10%', '7%', '3%'],
+            'نقاط القوة': ['خبرة طويلة، موارد كبيرة', 'أسعار تنافسية، سرعة التنفيذ', 'جودة عالية، سمعة جيدة', 'تقنيات حديثة، فريق متميز', 'مشاريع كبيرة، علاقات قوية'],
+            'نقاط الضعف': ['أسعار مرتفعة، بطء في التنفيذ', 'جودة متوسطة، موارد محدودة', 'قدرات محدودة، تأخر في التسليم', 'خبرة قليلة، تكلفة عالية', 'بطء في الاستجابة، مرونة قليلة']
+        }
+        
+        report_df = pd.DataFrame(data)
+        st.dataframe(report_df)
+        
+        # تصدير التقرير
+        st.download_button(
+            label="تصدير التقرير (Excel)",
+            data=self._export_to_excel(report_df),
+            file_name="تقرير_تحليل_المنافسين.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+        
+        # عرض رسم بياني
+        competitors_data = {
+            'المنافس': data['المنافس'],
+            'عدد المشاريع الفائزة': [int(x) for x in data['عدد المشاريع الفائزة']],
+            'نسبة الفوز': [float(x.replace('%', '')) for x in data['نسبة الفوز']]
+        }
+        
+        competitors_df = pd.DataFrame(competitors_data)
+        
+        fig = px.bar(competitors_df, x='المنافس', y=['عدد المشاريع الفائزة', 'نسبة الفوز'], barmode='group', title='تحليل المنافسين')
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_risk_analysis_report(self):
+        """عرض تقرير تحليل المخاطر"""
+        
+        st.markdown("#### تقرير تحليل المخاطر")
+        
+        # محاكاة بيانات التقرير
+        data = {
+            'المخاطرة': ['تأخر التوريدات', 'زيادة أسعار المواد', 'نقص العمالة الماهرة', 'تغيير نطاق العمل', 'ظروف جوية غير متوقعة', 'مشاكل في التربة', 'تأخر الموافقات الحكومية', 'مشاكل في التمويل'],
+            'الاحتمالية': ['متوسطة', 'عالية', 'متوسطة', 'منخفضة', 'منخفضة', 'منخفضة', 'متوسطة', 'منخفضة'],
+            'التأثير': ['عالي', 'عالي', 'متوسط', 'عالي', 'متوسط', 'عالي', 'عالي', 'عالي جداً'],
+            'درجة المخاطرة': ['عالية', 'عالية جداً', 'متوسطة', 'متوسطة', 'منخفضة', 'متوسطة', 'عالية', 'عالية'],
+            'استراتيجية التخفيف': ['وضع خطة توريدات بديلة', 'تثبيت أسعار المواد الرئيسية', 'التعاقد المسبق مع مقاولي الباطن', 'توثيق نطاق العمل بدقة', 'وضع خطة طوارئ للظروف الجوية', 'إجراء فحوصات شاملة للتربة', 'البدء في إجراءات الموافقات مبكراً', 'تأمين التمويل الكامل قبل البدء']
+        }
+        
+        report_df = pd.DataFrame(data)
+        st.dataframe(report_df)
+        
+        # تصدير التقرير
+        st.download_button(
+            label="تصدير التقرير (Excel)",
+            data=self._export_to_excel(report_df),
+            file_name="تقرير_تحليل_المخاطر.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+        
+        # عرض رسم بياني
+        risk_level_counts = report_df['درجة المخاطرة'].value_counts().reset_index()
+        risk_level_counts.columns = ['درجة المخاطرة', 'العدد']
+        
+        fig = px.pie(risk_level_counts, values='العدد', names='درجة المخاطرة', title='توزيع المخاطر حسب الدرجة')
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_risk_matrix_report(self):
+        """عرض تقرير مصفوفة المخاطر"""
+        
+        st.markdown("#### تقرير مصفوفة المخاطر")
+        
+        # محاكاة بيانات التقرير
+        data = {
+            'المخاطرة': ['تأخر التوريدات', 'زيادة أسعار المواد', 'نقص العمالة الماهرة', 'تغيير نطاق العمل', 'ظروف جوية غير متوقعة', 'مشاكل في التربة', 'تأخر الموافقات الحكومية', 'مشاكل في التمويل'],
+            'الاحتمالية': ['متوسطة', 'عالية', 'متوسطة', 'منخفضة', 'منخفضة', 'منخفضة', 'متوسطة', 'منخفضة'],
+            'التأثير': ['عالي', 'عالي', 'متوسط', 'عالي', 'متوسط', 'عالي', 'عالي', 'عالي جداً'],
+            'درجة المخاطرة': ['عالية', 'عالية جداً', 'متوسطة', 'متوسطة', 'منخفضة', 'متوسطة', 'عالية', 'عالية']
+        }
+        
+        report_df = pd.DataFrame(data)
+        st.dataframe(report_df)
+        
+        # تصدير التقرير
+        st.download_button(
+            label="تصدير التقرير (Excel)",
+            data=self._export_to_excel(report_df),
+            file_name="تقرير_مصفوفة_المخاطر.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+        
+        # عرض مصفوفة المخاطر
+        st.markdown("#### مصفوفة المخاطر")
+        
+        # تحويل درجات المخاطرة إلى قيم رقمية للرسم البياني
+        risk_levels = {
+            "منخفضة": 1,
+            "متوسطة": 2,
+            "عالية": 3,
+            "عالية جداً": 4
+        }
+        
+        probability_levels = {
+            "منخفضة": 1,
+            "متوسطة": 2,
+            "عالية": 3
+        }
+        
+        impact_levels = {
+            "منخفض": 1,
+            "متوسط": 2,
+            "عالي": 3,
+            "عالي جداً": 4
+        }
+        
+        # إنشاء DataFrame للرسم البياني
+        chart_data = []
+        for i, risk in enumerate(data['المخاطرة']):
+            chart_data.append({
+                "المخاطرة": risk,
+                "الاحتمالية": probability_levels.get(data['الاحتمالية'][i], 0),
+                "التأثير": impact_levels.get(data['التأثير'][i], 0),
+                "درجة المخاطرة": risk_levels.get(data['درجة المخاطرة'][i], 0)
+            })
+        
+        chart_df = pd.DataFrame(chart_data)
+        
+        fig = px.scatter(
+            chart_df,
+            x="الاحتمالية",
+            y="التأثير",
+            size="درجة المخاطرة",
+            color="درجة المخاطرة",
+            hover_name="المخاطرة",
+            size_max=20,
+            color_continuous_scale=px.colors.sequential.Reds
+        )
+        
+        fig.update_layout(
+            xaxis=dict(
+                tickmode='array',
+                tickvals=[1, 2, 3],
+                ticktext=['منخفضة', 'متوسطة', 'عالية']
+            ),
+            yaxis=dict(
+                tickmode='array',
+                tickvals=[1, 2, 3, 4],
+                ticktext=['منخفض', 'متوسط', 'عالي', 'عالي جداً']
+            )
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_risk_monitoring_report(self):
+        """عرض تقرير متابعة المخاطر"""
+        
+        st.markdown("#### تقرير متابعة المخاطر")
+        
+        # محاكاة بيانات التقرير
+        data = {
+            'المخاطرة': ['تأخر التوريدات', 'زيادة أسعار المواد', 'نقص العمالة الماهرة', 'تغيير نطاق العمل', 'ظروف جوية غير متوقعة'],
+            'درجة المخاطرة': ['عالية', 'عالية جداً', 'متوسطة', 'متوسطة', 'منخفضة'],
+            'حالة المخاطرة': ['نشطة', 'نشطة', 'تم التخفيف', 'نشطة', 'مغلقة'],
+            'الإجراءات المتخذة': ['تم التعاقد مع موردين بدلاء', 'تم تثبيت أسعار 70% من المواد', 'تم التعاقد مع شركة توظيف', 'تم توثيق نطاق العمل وإجراءات التغيير', 'تم وضع خطة طوارئ'],
+            'تاريخ آخر تحديث': ['2025-03-25', '2025-03-28', '2025-03-20', '2025-03-15', '2025-03-10'],
+            'المسؤول': ['مدير المشتريات', 'مدير المشروع', 'مدير الموارد البشرية', 'مدير المشروع', 'مدير الموقع'],
+            'ملاحظات': ['تأخر متوقع 5 أيام', 'زيادة متوقعة في التكلفة 3%', 'تم حل المشكلة', 'جاري متابعة التغييرات', 'تم إغلاق المخاطرة']
+        }
+        
+        report_df = pd.DataFrame(data)
+        st.dataframe(report_df)
+        
+        # تصدير التقرير
+        st.download_button(
+            label="تصدير التقرير (Excel)",
+            data=self._export_to_excel(report_df),
+            file_name="تقرير_متابعة_المخاطر.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+        
+        # عرض رسم بياني
+        status_counts = report_df['حالة المخاطرة'].value_counts().reset_index()
+        status_counts.columns = ['الحالة', 'العدد']
+        
+        fig = px.pie(status_counts, values='العدد', names='الحالة', title='توزيع المخاطر حسب الحالة')
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_risk_mitigation_report(self):
+        """عرض تقرير استراتيجيات التخفيف"""
+        
+        st.markdown("#### تقرير استراتيجيات التخفيف")
+        
+        # محاكاة بيانات التقرير
+        data = {
+            'المخاطرة': ['تأخر التوريدات', 'زيادة أسعار المواد', 'نقص العمالة الماهرة', 'تغيير نطاق العمل', 'ظروف جوية غير متوقعة', 'مشاكل في التربة', 'تأخر الموافقات الحكومية', 'مشاكل في التمويل'],
+            'استراتيجية التخفيف': ['تجنب', 'تخفيف', 'تخفيف', 'تجنب', 'قبول', 'تخفيف', 'تخفيف', 'نقل'],
+            'الإجراءات': [
+                'التعاقد مع موردين متعددين، وضع خطة توريدات بديلة، تخزين المواد الحرجة مسبقاً',
+                'تثبيت أسعار المواد الرئيسية، تخصيص احتياطي للتضخم، البحث عن بدائل أقل تكلفة',
+                'التعاقد المسبق مع مقاولي الباطن، تدريب العمالة، وضع خطة لزيادة الإنتاجية',
+                'توثيق نطاق العمل بدقة، وضع إجراءات صارمة لإدارة التغيير، تحديد صلاحيات اعتماد التغييرات',
+                'وضع خطة طوارئ للظروف الجوية، تضمين وقت احتياطي في الجدول الزمني',
+                'إجراء فحوصات شاملة للتربة قبل البدء في التنفيذ، تخصيص احتياطي للطوارئ',
+                'البدء في إجراءات الحصول على الموافقات مبكراً، متابعتها بشكل دوري، تعيين مسؤول اتصال مع الجهات الحكومية',
+                'تأمين التمويل الكامل قبل البدء في المشروع، إعداد خطة تمويل بديلة، التأمين ضد المخاطر المالية'
+            ],
+            'المسؤول': ['مدير المشتريات', 'مدير المشروع', 'مدير الموارد البشرية', 'مدير المشروع', 'مدير الموقع', 'مدير الموقع', 'مدير المشروع', 'المدير المالي'],
+            'الموعد النهائي': ['2025-04-15', '2025-04-01', '2025-04-10', '2025-03-25', '2025-04-05', '2025-03-20', '2025-03-30', '2025-03-15'],
+            'حالة التنفيذ': ['جاري التنفيذ', 'جاري التنفيذ', 'مكتمل', 'مكتمل', 'مكتمل', 'جاري التنفيذ', 'جاري التنفيذ', 'مكتمل']
+        }
+        
+        report_df = pd.DataFrame(data)
+        st.dataframe(report_df)
+        
+        # تصدير التقرير
+        st.download_button(
+            label="تصدير التقرير (Excel)",
+            data=self._export_to_excel(report_df),
+            file_name="تقرير_استراتيجيات_التخفيف.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+        
+        # عرض رسم بياني
+        strategy_counts = report_df['استراتيجية التخفيف'].value_counts().reset_index()
+        strategy_counts.columns = ['الاستراتيجية', 'العدد']
+        
+        fig = px.pie(strategy_counts, values='العدد', names='الاستراتيجية', title='توزيع استراتيجيات التخفيف')
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض حالة التنفيذ
+        status_counts = report_df['حالة التنفيذ'].value_counts().reset_index()
+        status_counts.columns = ['الحالة', 'العدد']
+        
+        fig = px.pie(status_counts, values='العدد', names='الحالة', title='حالة تنفيذ استراتيجيات التخفيف')
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _generate_custom_report(self, fields):
+        """إنشاء تقرير مخصص"""
+        
+        # محاكاة بيانات التقرير المخصص
+        data = {}
+        
+        all_fields = {
+            'رقم المشروع': ['P-2025-001', 'P-2025-002', 'P-2025-003', 'P-2025-004', 'P-2025-005', 'P-2025-006', 'P-2025-007', 'P-2025-008'],
+            'اسم المشروع': ['إنشاء مبنى إداري', 'تطوير شبكة طرق', 'إنشاء جسر', 'بناء مدرسة', 'تطوير شبكة مياه', 'إنشاء مستشفى', 'بناء مركز تجاري', 'تطوير حديقة عامة'],
+            'نوع المشروع': ['مباني', 'طرق', 'جسور', 'مباني', 'بنية تحتية', 'مباني', 'مباني', 'أخرى'],
+            'حالة المشروع': ['جديد', 'قيد التقديم', 'تم التقديم', 'فائز', 'جديد', 'فائز', 'خاسر', 'قيد التقديم'],
+            'تاريخ البدء': ['2025-04-15', '2025-05-01', '2025-04-10', '2025-03-15', '2025-05-10', '2025-02-20', '2025-03-10', '2025-04-20'],
+            'تاريخ الانتهاء': ['2026-04-15', '2026-05-01', '2026-04-10', '2025-12-15', '2026-05-10', '2026-02-20', '2025-12-10', '2025-10-20'],
+            'الميزانية': ['10,000,000', '15,000,000', '8,000,000', '5,000,000', '7,000,000', '20,000,000', '12,000,000', '3,000,000'],
+            'التكلفة الفعلية': ['0', '0', '0', '1,250,000', '0', '6,000,000', '0', '450,000'],
+            'نسبة الإنجاز': ['0%', '0%', '0%', '25%', '0%', '30%', '0%', '15%'],
+            'المخاطر': ['متوسطة', 'عالية', 'متوسطة', 'منخفضة', 'متوسطة', 'عالية', 'منخفضة', 'منخفضة'],
+            'الموقع': ['الرياض', 'جدة', 'الدمام', 'الرياض', 'جدة', 'الرياض', 'الدمام', 'الرياض'],
+            'المالك': ['وزارة المالية', 'وزارة النقل', 'وزارة النقل', 'وزارة التعليم', 'وزارة المياه', 'وزارة الصحة', 'القطاع الخاص', 'أمانة الرياض'],
+            'المقاول': ['شركة الإنشاءات المتطورة', 'شركة البناء الحديث', 'مؤسسة الإعمار', 'شركة التطوير العمراني', 'شركة الإنشاءات المتطورة', 'مجموعة الإنشاءات العربية', 'شركة البناء الحديث', 'مؤسسة الإعمار']
+        }
+        
+        for field in fields:
+            if field in all_fields:
+                data[field] = all_fields[field]
+        
+        return pd.DataFrame(data)
+    
+    def _export_to_excel(self, df):
+        """تصدير DataFrame إلى ملف Excel"""
+        
+        # محاكاة تصدير إلى Excel
+        output = BytesIO()
+        writer = pd.ExcelWriter(output, engine='xlsxwriter')
+        df.to_excel(writer, index=False, sheet_name='Sheet1')
+        writer.close()
+        processed_data = output.getvalue()
+        return processed_data

modules/resources/resources_app.py

@@ -0,0 +1,1706 @@
+"""
+وحدة الموارد - التطبيق الرئيسي
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import time
+import io
+import os
+import json
+import base64
+from pathlib import Path
+
+class ResourcesApp:
+    """وحدة الموارد"""
+    
+    def __init__(self):
+        """تهيئة وحدة الموارد"""
+        
+        # تهيئة حالة الجلسة
+        if 'resources_data' not in st.session_state:
+            # إنشاء بيانات افتراضية للموارد البشرية
+            np.random.seed(42)
+            
+            # إنشاء بيانات الموظفين
+            n_employees = 50
+            employee_ids = [f"EMP-{i+1:03d}" for i in range(n_employees)]
+            employee_names = [
+                "أحمد محمد", "محمد علي", "علي إبراهيم", "إبراهيم خالد", "خالد عبدالله",
+                "عبدالله سعد", "سعد فهد", "فهد ناصر", "ناصر سلطان", "سلطان عمر",
+                "عمر يوسف", "يوسف عبدالرحمن", "عبدالرحمن حسن", "حسن أحمد", "أحمد عبدالعزيز",
+                "عبدالعزيز سعود", "سعود فيصل", "فيصل تركي", "تركي بندر", "بندر سلمان",
+                "سلمان محمد", "محمد عبدالله", "عبدالله فهد", "فهد سعد", "سعد خالد",
+                "خالد علي", "علي عمر", "عمر سعيد", "سعيد ماجد", "ماجد فارس",
+                "فارس نايف", "نايف سامي", "سامي راشد", "راشد وليد", "وليد هاني",
+                "هاني زياد", "زياد طارق", "طارق عادل", "عادل فراس", "فراس باسم",
+                "باسم جمال", "جمال كريم", "كريم نبيل", "نبيل هشام", "هشام عماد",
+                "عماد أيمن", "أيمن رامي", "رامي سمير", "سمير وائل", "وائل مازن"
+            ]
+            employee_departments = np.random.choice(["الهندسة", "المشتريات", "المالية", "الموارد البشرية", "تقنية المعلومات", "التسويق", "المبيعات"], n_employees)
+            employee_positions = np.random.choice(["مدير", "مهندس", "محاسب", "مشرف", "أخصائي", "مساعد", "فني"], n_employees)
+            employee_skills = [
+                np.random.choice(["إدارة المشاريع", "التصميم الهندسي", "تحليل البيانات", "إدارة العقود", "التخطيط الاستراتيجي"], 
+                                size=np.random.randint(1, 4), 
+                                replace=False).tolist() 
+                for _ in range(n_employees)
+            ]
+            employee_experiences = np.random.randint(1, 20, n_employees)
+            employee_costs = np.random.randint(5000, 25000, n_employees)
+            employee_availabilities = np.random.choice([True, False], n_employees, p=[0.8, 0.2])
+            employee_ratings = np.random.uniform(3.0, 5.0, n_employees)
+            
+            # إنشاء DataFrame للموظفين
+            employees_data = {
+                "رقم الموظف": employee_ids,
+                "اسم الموظف": employee_names,
+                "القسم": employee_departments,
+                "المنصب": employee_positions,
+                "المهارات": employee_skills,
+                "سنوات الخبرة": employee_experiences,
+                "التكلفة الشهرية": employee_costs,
+                "متاح": employee_availabilities,
+                "التقييم": employee_ratings
+            }
+            
+            # إنشاء بيانات المعدات
+            n_equipment = 30
+            equipment_ids = [f"EQ-{i+1:03d}" for i in range(n_equipment)]
+            equipment_names = [
+                "حفارة كبيرة", "حفارة صغيرة", "جرافة", "شاحنة نقل", "رافعة كبيرة",
+                "رافعة متوسطة", "رافعة صغيرة", "خلاطة خرسانة", "مضخة خرسانة", "مولد كهرباء كبير",
+                "مولد كهرباء متوسط", "مولد كهرباء صغير", "ضاغط هواء", "آلة لحام", "معدات قياس",
+                "معدات اختبار", "سقالات", "قوالب خرسانية", "معدات سباكة", "معدات كهربائية",
+                "معدات تكييف", "معدات تدفئة", "معدات إضاءة", "معدات سلامة", "معدات إطفاء",
+                "سيارة نقل صغيرة", "سيارة نقل متوسطة", "سيارة نقل كبيرة", "معدات حفر يدوية", "معدات بناء يدوية"
+            ]
+            equipment_types = np.random.choice(["حفر", "نقل", "رفع", "خرسانة", "كهرباء", "قياس", "بناء", "سلامة"], n_equipment)
+            equipment_costs = np.random.randint(500, 5000, n_equipment)
+            equipment_availabilities = np.random.choice([True, False], n_equipment, p=[0.7, 0.3])
+            equipment_conditions = np.random.choice(["ممتاز", "جيد", "متوسط", "سيء"], n_equipment, p=[0.4, 0.3, 0.2, 0.1])
+            equipment_locations = np.random.choice(["المستودع", "موقع المشروع 1", "موقع المشروع 2", "موقع المشروع 3", "في الصيانة"], n_equipment)
+            
+            # إنشاء DataFrame للمعدات
+            equipment_data = {
+                "رقم المعدة": equipment_ids,
+                "اسم المعدة": equipment_names,
+                "النوع": equipment_types,
+                "التكلفة اليومية": equipment_costs,
+                "متاحة": equipment_availabilities,
+                "الحالة": equipment_conditions,
+                "الموقع": equipment_locations
+            }
+            
+            # إنشاء بيانات المواد
+            n_materials = 40
+            material_ids = [f"MAT-{i+1:03d}" for i in range(n_materials)]
+            material_names = [
+                "خرسانة جاهزة", "حديد تسليح", "طابوق", "أسمنت", "رمل", "بحص", "خشب", "ألمنيوم", "زجاج", "دهان",
+                "سيراميك", "رخام", "جبس", "عازل مائي", "عازل حراري", "أنابيب PVC", "أسلاك كهربائية", "مفاتيح كهربائية",
+                "إنارة", "تكييف", "مصاعد", "أبواب خشبية", "أبواب حديدية", "نوافذ ألمنيوم", "نوافذ زجاجية",
+                "أرضيات خشبية", "أرضيات بلاط", "أرضيات رخام", "أرضيات سيراميك", "أرضيات بورسلين",
+                "دهان داخلي", "دهان خارجي", "مواد عزل", "مواد تشطيب", "مواد كهربائية", "مواد سباكة",
+                "مواد تكييف", "مواد إضاءة", "مواد سلامة", "مواد متنوعة"
+            ]
+            material_units = np.random.choice(["م3", "طن", "م2", "كجم", "لتر", "قطعة", "متر"], n_materials)
+            material_quantities = np.random.randint(10, 1000, n_materials)
+            material_costs = np.random.randint(50, 5000, n_materials)
+            material_suppliers = np.random.choice(["المورد 1", "المورد 2", "المورد 3", "المورد 4", "المورد 5"], n_materials)
+            material_lead_times = np.random.randint(1, 30, n_materials)
+            
+            # إنشاء DataFrame للمواد
+            materials_data = {
+                "رقم المادة": material_ids,
+                "اسم المادة": material_names,
+                "الوحدة": material_units,
+                "الكمية المتاحة": material_quantities,
+                "تكلفة الوحدة": material_costs,
+                "المورد": material_suppliers,
+                "مدة التوريد (يوم)": material_lead_times
+            }
+            
+            # إنشاء بيانات المشاريع
+            n_projects = 10
+            project_ids = [f"PRJ-{i+1:03d}" for i in range(n_projects)]
+            project_names = [
+                "مشروع إنشاء مبنى إداري", "مشروع إنشاء مبنى سكني", "مشروع إنشاء مدرسة",
+                "مشروع إنشاء مستشفى", "مشروع تطوير طرق", "مشروع إنشاء جسر",
+                "مشروع بنية تحتية", "مشروع إنشاء مركز تجاري", "مشروع إنشاء فندق",
+                "مشروع إنشاء مصنع"
+            ]
+            project_locations = np.random.choice(["الرياض", "جدة", "الدمام", "مكة", "المدينة", "أبها", "تبوك"], n_projects)
+            project_start_dates = [
+                (datetime.now() - timedelta(days=np.random.randint(0, 180))).strftime("%Y-%m-%d")
+                for _ in range(n_projects)
+            ]
+            project_end_dates = [
+                (datetime.strptime(start_date, "%Y-%m-%d") + timedelta(days=np.random.randint(180, 720))).strftime("%Y-%m-%d")
+                for start_date in project_start_dates
+            ]
+            project_budgets = np.random.randint(1000000, 50000000, n_projects)
+            project_statuses = np.random.choice(["قيد التنفيذ", "مكتمل", "متوقف", "مخطط"], n_projects)
+            
+            # إنشاء DataFrame للمشاريع
+            projects_data = {
+                "رقم المشروع": project_ids,
+                "اسم المشروع": project_names,
+                "الموقع": project_locations,
+                "تاريخ البدء": project_start_dates,
+                "تاريخ الانتهاء": project_end_dates,
+                "الميزانية": project_budgets,
+                "الحالة": project_statuses
+            }
+            
+            # إنشاء بيانات تخصيص الموارد للمشاريع
+            n_allocations = 100
+            allocation_ids = [f"ALLOC-{i+1:03d}" for i in range(n_allocations)]
+            allocation_projects = np.random.choice(project_ids, n_allocations)
+            allocation_resource_types = np.random.choice(["موظف", "معدة", "مادة"], n_allocations)
+            allocation_resource_ids = []
+            for res_type in allocation_resource_types:
+                if res_type == "موظف":
+                    allocation_resource_ids.append(np.random.choice(employee_ids))
+                elif res_type == "معدة":
+                    allocation_resource_ids.append(np.random.choice(equipment_ids))
+                else:
+                    allocation_resource_ids.append(np.random.choice(material_ids))
+            
+            allocation_start_dates = [
+                (datetime.now() - timedelta(days=np.random.randint(0, 90))).strftime("%Y-%m-%d")
+                for _ in range(n_allocations)
+            ]
+            allocation_end_dates = [
+                (datetime.strptime(start_date, "%Y-%m-%d") + timedelta(days=np.random.randint(30, 180))).strftime("%Y-%m-%d")
+                for start_date in allocation_start_dates
+            ]
+            allocation_quantities = np.random.randint(1, 10, n_allocations)
+            allocation_costs = np.random.randint(5000, 50000, n_allocations)
+            
+            # إنشاء DataFrame لتخصيص الموارد
+            allocations_data = {
+                "رقم التخصيص": allocation_ids,
+                "رقم المشروع": allocation_projects,
+                "نوع المورد": allocation_resource_types,
+                "رقم المورد": allocation_resource_ids,
+                "تاريخ البدء": allocation_start_dates,
+                "تاريخ الانتهاء": allocation_end_dates,
+                "الكمية": allocation_quantities,
+                "التكلفة": allocation_costs
+            }
+            
+            # تخزين البيانات في حالة الجلسة
+            st.session_state.resources_data = {
+                "employees": pd.DataFrame(employees_data),
+                "equipment": pd.DataFrame(equipment_data),
+                "materials": pd.DataFrame(materials_data),
+                "projects": pd.DataFrame(projects_data),
+                "allocations": pd.DataFrame(allocations_data)
+            }
+    
+    def render(self):
+        """عرض واجهة وحدة الموارد"""
+        
+        st.markdown("<h1 class='module-title'>وحدة الموارد</h1>", unsafe_allow_html=True)
+        
+        tabs = st.tabs([
+            "لوحة المعلومات", 
+            "الموارد البشرية",
+            "المعدات",
+            "المواد",
+            "تخصيص الموارد",
+            "تخطيط الموارد"
+        ])
+        
+        with tabs[0]:
+            self._render_dashboard_tab()
+        
+        with tabs[1]:
+            self._render_human_resources_tab()
+        
+        with tabs[2]:
+            self._render_equipment_tab()
+        
+        with tabs[3]:
+            self._render_materials_tab()
+        
+        with tabs[4]:
+            self._render_resource_allocation_tab()
+        
+        with tabs[5]:
+            self._render_resource_planning_tab()
+    
+    def _render_dashboard_tab(self):
+        """عرض تبويب لوحة المعلومات"""
+        
+        st.markdown("### لوحة معلومات الموارد")
+        
+        # استخراج البيانات
+        employees_df = st.session_state.resources_data["employees"]
+        equipment_df = st.session_state.resources_data["equipment"]
+        materials_df = st.session_state.resources_data["materials"]
+        projects_df = st.session_state.resources_data["projects"]
+        allocations_df = st.session_state.resources_data["allocations"]
+        
+        # عرض مؤشرات الأداء الرئيسية
+        st.markdown("#### مؤشرات الأداء الرئيسية")
+        
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            total_employees = len(employees_df)
+            available_employees = len(employees_df[employees_df["متاح"] == True])
+            st.metric("الموظفون", f"{available_employees}/{total_employees}")
+        
+        with col2:
+            total_equipment = len(equipment_df)
+            available_equipment = len(equipment_df[equipment_df["متاحة"] == True])
+            st.metric("المعدات", f"{available_equipment}/{total_equipment}")
+        
+        with col3:
+            total_materials = len(materials_df)
+            low_stock_materials = len(materials_df[materials_df["ا��كمية المتاحة"] < 50])
+            st.metric("المواد", f"{total_materials}", f"-{low_stock_materials} منخفضة المخزون")
+        
+        with col4:
+            total_projects = len(projects_df)
+            active_projects = len(projects_df[projects_df["الحالة"] == "قيد التنفيذ"])
+            st.metric("المشاريع النشطة", f"{active_projects}/{total_projects}")
+        
+        # عرض توزيع الموارد البشرية حسب القسم
+        st.markdown("#### توزيع الموارد البشرية حسب القسم")
+        
+        dept_counts = employees_df["القسم"].value_counts().reset_index()
+        dept_counts.columns = ["القسم", "العدد"]
+        
+        fig = px.pie(
+            dept_counts,
+            values="العدد",
+            names="القسم",
+            title="توزيع الموظفين حسب القسم",
+            color="القسم"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع المعدات حسب النوع
+        st.markdown("#### توزيع المعدات حسب النوع")
+        
+        type_counts = equipment_df["النوع"].value_counts().reset_index()
+        type_counts.columns = ["النوع", "العدد"]
+        
+        fig = px.bar(
+            type_counts,
+            x="النوع",
+            y="العدد",
+            title="توزيع المعدات حسب النوع",
+            color="النوع",
+            text_auto=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع المواد حسب المورد
+        st.markdown("#### توزيع المواد حسب المورد")
+        
+        supplier_counts = materials_df["المورد"].value_counts().reset_index()
+        supplier_counts.columns = ["المورد", "العدد"]
+        
+        fig = px.pie(
+            supplier_counts,
+            values="العدد",
+            names="المورد",
+            title="توزيع المواد حسب المورد",
+            color="المورد"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع تكاليف الموارد
+        st.markdown("#### توزيع تكاليف الموارد")
+        
+        # حساب إجمالي تكاليف الموظفين
+        total_employee_cost = employees_df["التكلفة الشهرية"].sum()
+        
+        # حساب إجمالي تكاليف المعدات (افتراضياً لشهر واحد)
+        total_equipment_cost = equipment_df["التكلفة اليومية"].sum() * 30
+        
+        # حساب إجمالي تكاليف المواد
+        total_material_cost = (materials_df["الكمية المتاحة"] * materials_df["تكلفة الوحدة"]).sum()
+        
+        # إنشاء DataFrame لتوزيع التكاليف
+        cost_distribution = pd.DataFrame({
+            "نوع المورد": ["الموظفون", "المعدات", "المواد"],
+            "التكلفة": [total_employee_cost, total_equipment_cost, total_material_cost]
+        })
+        
+        fig = px.pie(
+            cost_distribution,
+            values="التكلفة",
+            names="نوع المورد",
+            title="توزيع تكاليف الموارد",
+            color="نوع المورد",
+            color_discrete_map={
+                "الموظفون": "#3498db",
+                "المعدات": "#2ecc71",
+                "المواد": "#f39c12"
+            }
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض تخصيص الموارد للمشاريع
+        st.markdown("#### تخصيص الموارد للمشاريع")
+        
+        # حساب عدد الموارد المخصصة لكل مشروع
+        project_allocations = allocations_df["رقم المشروع"].value_counts().reset_index()
+        project_allocations.columns = ["رقم المشروع", "عدد الموارد المخصصة"]
+        
+        # دمج بيانات المشاريع مع بيانات التخصيص
+        project_allocations = project_allocations.merge(
+            projects_df[["رقم المشروع", "اسم المشروع", "الحالة"]],
+            on="رقم المشروع",
+            how="left"
+        )
+        
+        fig = px.bar(
+            project_allocations,
+            x="اسم المشروع",
+            y="عدد الموارد المخصصة",
+            title="تخصيص الموارد للمشاريع",
+            color="الحالة",
+            text_auto=True,
+            color_discrete_map={
+                "قيد التنفيذ": "#3498db",
+                "مكتمل": "#2ecc71",
+                "متوقف": "#e74c3c",
+                "مخطط": "#f39c12"
+            }
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع أنواع الموارد المخصصة
+        st.markdown("#### توزيع أنواع الموارد المخصصة")
+        
+        resource_type_counts = allocations_df["نوع المورد"].value_counts().reset_index()
+        resource_type_counts.columns = ["نوع المورد", "العدد"]
+        
+        fig = px.pie(
+            resource_type_counts,
+            values="العدد",
+            names="نوع المورد",
+            title="توزيع أنواع الموارد المخصصة",
+            color="نوع المورد",
+            color_discrete_map={
+                "موظف": "#3498db",
+                "معدة": "#2ecc71",
+                "مادة": "#f39c12"
+            }
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+    
+    def _render_human_resources_tab(self):
+        """عرض تبويب الموارد البشرية"""
+        
+        st.markdown("### إدارة الموارد البشرية")
+        
+        # استخراج البيانات
+        employees_df = st.session_state.resources_data["employees"]
+        
+        # عرض خيارات التصفية
+        st.markdown("#### خيارات التصفية")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            selected_departments = st.multiselect(
+                "القسم",
+                options=employees_df["القسم"].unique(),
+                default=employees_df["القسم"].unique()
+            )
+        
+        with col2:
+            selected_positions = st.multiselect(
+                "المنصب",
+                options=employees_df["المنصب"].unique(),
+                default=employees_df["المنصب"].unique()
+            )
+        
+        with col3:
+            availability_filter = st.selectbox(
+                "الإتاحة",
+                options=["الكل", "متاح فقط", "غير متاح فقط"]
+            )
+        
+        # تطبيق التصفية
+        filtered_df = employees_df[
+            employees_df["القسم"].isin(selected_departments) &
+            employees_df["المنصب"].isin(selected_positions)
+        ]
+        
+        if availability_filter == "متاح فقط":
+            filtered_df = filtered_df[filtered_df["متاح"] == True]
+        elif availability_filter == "غير متاح فقط":
+            filtered_df = filtered_df[filtered_df["متاح"] == False]
+        
+        # عرض البيانات المصفاة
+        st.markdown("#### قائمة الموظفين")
+        
+        st.dataframe(
+            filtered_df,
+            column_config={
+                "رقم الموظف": st.column_config.TextColumn("رقم الموظف"),
+                "اسم الموظف": st.column_config.TextColumn("اسم الموظف"),
+                "القسم": st.column_config.TextColumn("القسم"),
+                "المنصب": st.column_config.TextColumn("المنصب"),
+                "المهارات": st.column_config.ListColumn("المهارات"),
+                "سنوات الخبرة": st.column_config.NumberColumn("سنوات الخبرة"),
+                "التكلفة الشهرية": st.column_config.NumberColumn("التكلفة الشهرية", format="%.2f ريال"),
+                "متاح": st.column_config.CheckboxColumn("متاح"),
+                "التقييم": st.column_config.ProgressColumn("التقييم", min_value=0, max_value=5)
+            },
+            use_container_width=True,
+            hide_index=True
+        )
+        
+        # عرض إحصائيات الموارد البشرية
+        st.markdown("#### إحصائيات الموارد البشرية")
+        
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            total_employees = len(filtered_df)
+            st.metric("إجمالي الموظفين", f"{total_employees}")
+        
+        with col2:
+            available_employees = len(filtered_df[filtered_df["متاح"] == True])
+            availability_rate = available_employees / total_employees * 100 if total_employees > 0 else 0
+            st.metric("معدل الإتاحة", f"{availability_rate:.1f}%")
+        
+        with col3:
+            avg_experience = filtered_df["سنوات الخبرة"].mean()
+            st.metric("متوسط سنوات الخبرة", f"{avg_experience:.1f} سنة")
+        
+        with col4:
+            avg_cost = filtered_df["التكلفة الشهرية"].mean()
+            st.metric("متوسط التكلفة الشهرية", f"{avg_cost:.0f} ريال")
+        
+        # عرض توزيع الموظفين حسب القسم
+        st.markdown("#### توزيع الموظفين حسب القسم")
+        
+        dept_counts = filtered_df["القسم"].value_counts().reset_index()
+        dept_counts.columns = ["القسم", "العدد"]
+        
+        fig = px.bar(
+            dept_counts,
+            x="القسم",
+            y="العدد",
+            title="توزيع الموظفين حسب القسم",
+            color="القسم",
+            text_auto=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع الموظفين حسب المنصب
+        st.markdown("#### توزيع الموظفين حسب المنصب")
+        
+        position_counts = filtered_df["المنصب"].value_counts().reset_index()
+        position_counts.columns = ["المنصب", "العدد"]
+        
+        fig = px.pie(
+            position_counts,
+            values="العدد",
+            names="المنصب",
+            title="توزيع الموظفين حسب المنصب",
+            color="المنصب"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع الموظفين حسب سنوات الخبرة
+        st.markdown("#### توزيع الموظفين حسب سنوات الخبرة")
+        
+        # إنشاء فئات لسنوات الخبرة
+        experience_bins = [0, 3, 5, 10, 15, 20]
+        experience_labels = ["أقل من 3 سنوات", "3-5 سنوات", "6-10 سنوات", "11-15 سنة", "أكثر من 15 سنة"]
+        
+        filtered_df["فئة الخبرة"] = pd.cut(filtered_df["سنوات الخبرة"], bins=experience_bins, labels=experience_labels, right=False)
+        
+        experience_counts = filtered_df["فئة الخبرة"].value_counts().reset_index()
+        experience_counts.columns = ["فئة الخبرة", "العدد"]
+        
+        fig = px.bar(
+            experience_counts,
+            x="فئة الخبرة",
+            y="العدد",
+            title="توزيع الموظفين حسب سنوات الخبرة",
+            color="فئة الخبرة",
+            text_auto=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع المهارات
+        st.markdown("#### توزيع المهارات")
+        
+        # استخراج جميع المهارات
+        all_skills = []
+        for skills_list in filtered_df["المهارات"]:
+            all_skills.extend(skills_list)
+        
+        skill_counts = pd.Series(all_skills).value_counts().reset_index()
+        skill_counts.columns = ["المهارة", "العدد"]
+        
+        fig = px.bar(
+            skill_counts,
+            x="المهارة",
+            y="العدد",
+            title="توزيع المهارات",
+            color="المهارة",
+            text_auto=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض العلاقة بين سنوات الخبرة والتكلفة
+        st.markdown("#### العلاقة بين سنوات الخبرة والتكلفة")
+        
+        fig = px.scatter(
+            filtered_df,
+            x="سنوات الخبرة",
+            y="التكلفة الشهرية",
+            color="القسم",
+            size="التقييم",
+            hover_name="اسم الموظف",
+            hover_data=["المنصب", "متاح"],
+            title="العلاقة بين سنوات الخبرة والتكلفة الشهرية"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # إضافة موظف جديد
+        st.markdown("#### إضافة موظف جديد")
+        
+        with st.form("add_employee_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                new_employee_name = st.text_input("اسم الموظف")
+                new_employee_department = st.selectbox("القسم", options=employees_df["القسم"].unique())
+                new_employee_position = st.selectbox("المنصب", options=employees_df["المنصب"].unique())
+                new_employee_experience = st.number_input("سنوات الخبرة", min_value=0, max_value=40, value=5)
+            
+            with col2:
+                new_employee_skills = st.multiselect(
+                    "المهارات",
+                    options=["إدارة المشاريع", "التصميم الهندسي", "تحليل البيانات", "إدارة العقود", "التخطيط الاستراتيجي", "إدارة الموارد", "إدارة المخاطر", "إدارة الجودة", "إدارة التكاليف", "إدارة الوقت"]
+                )
+                new_employee_cost = st.number_input("التكلفة الشهرية", min_value=3000, max_value=50000, value=10000)
+                new_employee_available = st.checkbox("متاح", value=True)
+                new_employee_rating = st.slider("التقييم", min_value=1.0, max_value=5.0, value=4.0, step=0.1)
+            
+            submit_button = st.form_submit_button("إضافة موظف")
+            
+            if submit_button:
+                if new_employee_name:
+                    # إنشاء رقم موظف جديد
+                    new_employee_id = f"EMP-{len(employees_df) + 1:03d}"
+                    
+                    # إضافة الموظف الجديد
+                    new_employee = pd.DataFrame({
+                        "رقم الموظف": [new_employee_id],
+                        "اسم الموظف": [new_employee_name],
+                        "القسم": [new_employee_department],
+                        "المنصب": [new_employee_position],
+                        "المهارات": [new_employee_skills],
+                        "سنوات الخبرة": [new_employee_experience],
+                        "التكلفة الشهرية": [new_employee_cost],
+                        "متاح": [new_employee_available],
+                        "التقييم": [new_employee_rating]
+                    })
+                    
+                    # تحديث DataFrame الموظفين
+                    st.session_state.resources_data["employees"] = pd.concat([employees_df, new_employee], ignore_index=True)
+                    
+                    st.success(f"تم إضافة الموظف {new_employee_name} بنجاح!")
+                    st.rerun()
+                else:
+                    st.error("يرجى إدخال اسم الموظف")
+    
+    def _render_equipment_tab(self):
+        """عرض تبويب المعدات"""
+        
+        st.markdown("### إدارة المعدات")
+        
+        # استخراج البيانات
+        equipment_df = st.session_state.resources_data["equipment"]
+        
+        # عرض خيارات التصفية
+        st.markdown("#### خيارات التصفية")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            selected_types = st.multiselect(
+                "النوع",
+                options=equipment_df["النوع"].unique(),
+                default=equipment_df["النوع"].unique()
+            )
+        
+        with col2:
+            selected_conditions = st.multiselect(
+                "الحالة",
+                options=equipment_df["الحالة"].unique(),
+                default=equipment_df["الحالة"].unique()
+            )
+        
+        with col3:
+            availability_filter = st.selectbox(
+                "الإتاحة",
+                options=["الكل", "متاحة فقط", "غير متاحة فقط"],
+                key="equipment_availability"
+            )
+        
+        # تطبيق التصفية
+        filtered_df = equipment_df[
+            equipment_df["النوع"].isin(selected_types) &
+            equipment_df["الحالة"].isin(selected_conditions)
+        ]
+        
+        if availability_filter == "متاحة فقط":
+            filtered_df = filtered_df[filtered_df["متاحة"] == True]
+        elif availability_filter == "غير متاحة فقط":
+            filtered_df = filtered_df[filtered_df["متاحة"] == False]
+        
+        # عرض البيانات المصفاة
+        st.markdown("#### قائمة المعدات")
+        
+        st.dataframe(
+            filtered_df,
+            column_config={
+                "رقم المعدة": st.column_config.TextColumn("رقم المعدة"),
+                "اسم المعدة": st.column_config.TextColumn("اسم المعدة"),
+                "النوع": st.column_config.TextColumn("النوع"),
+                "التكلفة اليومية": st.column_config.NumberColumn("التكلفة اليومية", format="%.2f ريال"),
+                "متاحة": st.column_config.CheckboxColumn("متاحة"),
+                "الحالة": st.column_config.TextColumn("الحالة"),
+                "الموقع": st.column_config.TextColumn("الموقع")
+            },
+            use_container_width=True,
+            hide_index=True
+        )
+        
+        # عرض إحصائيات المعدات
+        st.markdown("#### إحصائيات المعدات")
+        
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            total_equipment = len(filtered_df)
+            st.metric("إجمالي المعدات", f"{total_equipment}")
+        
+        with col2:
+            available_equipment = len(filtered_df[filtered_df["متاحة"] == True])
+            availability_rate = available_equipment / total_equipment * 100 if total_equipment > 0 else 0
+            st.metric("معدل الإتاحة", f"{availability_rate:.1f}%")
+        
+        with col3:
+            good_condition = len(filtered_df[filtered_df["الحالة"].isin(["ممتاز", "جيد"])])
+            good_condition_rate = good_condition / total_equipment * 100 if total_equipment > 0 else 0
+            st.metric("معدل الحالة الجيدة", f"{good_condition_rate:.1f}%")
+        
+        with col4:
+            avg_cost = filtered_df["التكلفة اليومية"].mean()
+            st.metric("متوسط التكلفة اليومية", f"{avg_cost:.0f} ريال")
+        
+        # عرض توزيع المعدات حسب النوع
+        st.markdown("#### توزيع المعدات حسب النوع")
+        
+        type_counts = filtered_df["النوع"].value_counts().reset_index()
+        type_counts.columns = ["النوع", "العدد"]
+        
+        fig = px.bar(
+            type_counts,
+            x="النوع",
+            y="العدد",
+            title="توزيع المعدات حسب النوع",
+            color="النوع",
+            text_auto=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع المعدات حسب الحالة
+        st.markdown("#### توزيع المعدات حسب الحالة")
+        
+        condition_counts = filtered_df["الحالة"].value_counts().reset_index()
+        condition_counts.columns = ["الحالة", "العدد"]
+        
+        fig = px.pie(
+            condition_counts,
+            values="العدد",
+            names="الحالة",
+            title="توزيع المعدات حسب الحالة",
+            color="الحالة",
+            color_discrete_map={
+                "ممتاز": "#2ecc71",
+                "جيد": "#3498db",
+                "متوسط": "#f39c12",
+                "سيء": "#e74c3c"
+            }
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع المعدات حسب الموقع
+        st.markdown("#### توزيع المعدات حسب الموقع")
+        
+        location_counts = filtered_df["الموقع"].value_counts().reset_index()
+        location_counts.columns = ["الموقع", "العدد"]
+        
+        fig = px.bar(
+            location_counts,
+            x="الموقع",
+            y="العدد",
+            title="توزيع المعدات حسب الموقع",
+            color="الموقع",
+            text_auto=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض العلاقة بين نوع المعدة والتكلفة
+        st.markdown("#### العلاقة بين نوع المعدة والتكلفة")
+        
+        type_cost = filtered_df.groupby("النوع")["التكلفة اليومية"].mean().reset_index()
+        type_cost.columns = ["النوع", "متوسط التكلفة اليومية"]
+        
+        fig = px.bar(
+            type_cost,
+            x="النوع",
+            y="متوسط التكلفة اليومية",
+            title="متوسط التكلفة اليومية حسب نوع المعدة",
+            color="النوع",
+            text_auto=".0f"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # إضافة معدة جديدة
+        st.markdown("#### إضافة معدة جديدة")
+        
+        with st.form("add_equipment_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                new_equipment_name = st.text_input("اسم المعدة")
+                new_equipment_type = st.selectbox("النوع", options=equipment_df["النوع"].unique())
+                new_equipment_cost = st.number_input("التكلفة اليومية", min_value=100, max_value=10000, value=1000)
+            
+            with col2:
+                new_equipment_available = st.checkbox("متاحة", value=True)
+                new_equipment_condition = st.selectbox("الحالة", options=["ممتاز", "جيد", "متوسط", "سيء"])
+                new_equipment_location = st.selectbox("الموقع", options=equipment_df["الموقع"].unique())
+            
+            submit_button = st.form_submit_button("إضافة معدة")
+            
+            if submit_button:
+                if new_equipment_name:
+                    # إنشاء رقم معدة جديد
+                    new_equipment_id = f"EQ-{len(equipment_df) + 1:03d}"
+                    
+                    # إضافة المعدة الجديدة
+                    new_equipment = pd.DataFrame({
+                        "رقم المعدة": [new_equipment_id],
+                        "اسم المعدة": [new_equipment_name],
+                        "النوع": [new_equipment_type],
+                        "التكلفة اليومية": [new_equipment_cost],
+                        "متاحة": [new_equipment_available],
+                        "الحالة": [new_equipment_condition],
+                        "الموقع": [new_equipment_location]
+                    })
+                    
+                    # تحديث DataFrame المعدات
+                    st.session_state.resources_data["equipment"] = pd.concat([equipment_df, new_equipment], ignore_index=True)
+                    
+                    st.success(f"تم إضافة المعدة {new_equipment_name} ب��جاح!")
+                    st.rerun()
+                else:
+                    st.error("يرجى إدخال اسم المعدة")
+    
+    def _render_materials_tab(self):
+        """عرض تبويب المواد"""
+        
+        st.markdown("### إدارة المواد")
+        
+        # استخراج البيانات
+        materials_df = st.session_state.resources_data["materials"]
+        
+        # عرض خيارات التصفية
+        st.markdown("#### خيارات التصفية")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            selected_units = st.multiselect(
+                "الوحدة",
+                options=materials_df["الوحدة"].unique(),
+                default=materials_df["الوحدة"].unique()
+            )
+        
+        with col2:
+            selected_suppliers = st.multiselect(
+                "المورد",
+                options=materials_df["المورد"].unique(),
+                default=materials_df["المورد"].unique()
+            )
+        
+        with col3:
+            stock_filter = st.selectbox(
+                "المخزون",
+                options=["الكل", "منخفض المخزون", "مخزون كافي"]
+            )
+        
+        # تطبيق التصفية
+        filtered_df = materials_df[
+            materials_df["الوحدة"].isin(selected_units) &
+            materials_df["المورد"].isin(selected_suppliers)
+        ]
+        
+        if stock_filter == "منخفض المخزون":
+            filtered_df = filtered_df[filtered_df["الكمية المتاحة"] < 50]
+        elif stock_filter == "مخزون كافي":
+            filtered_df = filtered_df[filtered_df["الكمية المتاحة"] >= 50]
+        
+        # عرض البيانات المصفاة
+        st.markdown("#### قائمة المواد")
+        
+        st.dataframe(
+            filtered_df,
+            column_config={
+                "رقم المادة": st.column_config.TextColumn("رقم المادة"),
+                "اسم المادة": st.column_config.TextColumn("اسم المادة"),
+                "الوحدة": st.column_config.TextColumn("الوحدة"),
+                "الكمية المتاحة": st.column_config.NumberColumn("الكمية المتاحة"),
+                "تكلفة الوحدة": st.column_config.NumberColumn("تكلفة الوحدة", format="%.2f ريال"),
+                "المورد": st.column_config.TextColumn("المورد"),
+                "مدة التوريد (يوم)": st.column_config.NumberColumn("مدة التوريد (يوم)")
+            },
+            use_container_width=True,
+            hide_index=True
+        )
+        
+        # عرض إحصائيات المواد
+        st.markdown("#### إحصائيات المواد")
+        
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            total_materials = len(filtered_df)
+            st.metric("إجمالي المواد", f"{total_materials}")
+        
+        with col2:
+            low_stock_materials = len(filtered_df[filtered_df["الكمية المتاحة"] < 50])
+            low_stock_rate = low_stock_materials / total_materials * 100 if total_materials > 0 else 0
+            st.metric("نسبة المواد منخفضة المخزون", f"{low_stock_rate:.1f}%")
+        
+        with col3:
+            avg_lead_time = filtered_df["مدة التوريد (يوم)"].mean()
+            st.metric("متوسط مدة التوريد", f"{avg_lead_time:.1f} يوم")
+        
+        with col4:
+            total_inventory_value = (filtered_df["الكمية المتاحة"] * filtered_df["تكلفة الوحدة"]).sum()
+            st.metric("إجمالي قيمة المخزون", f"{total_inventory_value:,.0f} ريال")
+        
+        # عرض توزيع المواد حسب المورد
+        st.markdown("#### توزيع المواد حسب المورد")
+        
+        supplier_counts = filtered_df["المورد"].value_counts().reset_index()
+        supplier_counts.columns = ["المورد", "العدد"]
+        
+        fig = px.pie(
+            supplier_counts,
+            values="العدد",
+            names="المورد",
+            title="توزيع المواد حسب المورد",
+            color="المورد"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع المواد حسب الوحدة
+        st.markdown("#### توزيع المواد حسب الوحدة")
+        
+        unit_counts = filtered_df["الوحدة"].value_counts().reset_index()
+        unit_counts.columns = ["الوحدة", "العدد"]
+        
+        fig = px.bar(
+            unit_counts,
+            x="الوحدة",
+            y="العدد",
+            title="توزيع المواد حسب الوحدة",
+            color="الوحدة",
+            text_auto=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض المواد منخفضة المخزون
+        st.markdown("#### المواد منخفضة المخزون")
+        
+        low_stock_df = filtered_df[filtered_df["الكمية المتاحة"] < 50].sort_values("الكمية المتاحة")
+        
+        if not low_stock_df.empty:
+            fig = px.bar(
+                low_stock_df,
+                x="اسم المادة",
+                y="الكمية المتاحة",
+                title="المواد منخفضة المخزون",
+                color="الكمية المتاحة",
+                color_continuous_scale="Reds_r",
+                text_auto=True
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+        else:
+            st.info("لا توجد مواد منخفضة المخزون")
+        
+        # عرض العلاقة بين مدة التوريد والمورد
+        st.markdown("#### العلاقة بين مدة التوريد والمورد")
+        
+        supplier_lead_time = filtered_df.groupby("المورد")["مدة التوريد (يوم)"].mean().reset_index()
+        supplier_lead_time.columns = ["المورد", "متوسط مدة التوريد (يوم)"]
+        
+        fig = px.bar(
+            supplier_lead_time,
+            x="المورد",
+            y="متوسط مدة التوريد (يوم)",
+            title="متوسط مدة التوريد حسب المورد",
+            color="المورد",
+            text_auto=".1f"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # إضافة مادة جديدة
+        st.markdown("#### إضافة مادة جديدة")
+        
+        with st.form("add_material_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                new_material_name = st.text_input("اسم المادة")
+                new_material_unit = st.selectbox("الوحدة", options=materials_df["الوحدة"].unique())
+                new_material_quantity = st.number_input("الكمية المتاحة", min_value=0, max_value=10000, value=100)
+            
+            with col2:
+                new_material_cost = st.number_input("تكلفة الوحدة", min_value=1, max_value=10000, value=100)
+                new_material_supplier = st.selectbox("المورد", options=materials_df["المورد"].unique())
+                new_material_lead_time = st.number_input("مدة التوريد (يوم)", min_value=1, max_value=90, value=7)
+            
+            submit_button = st.form_submit_button("إضافة مادة")
+            
+            if submit_button:
+                if new_material_name:
+                    # إنشاء رقم مادة جديد
+                    new_material_id = f"MAT-{len(materials_df) + 1:03d}"
+                    
+                    # إضافة المادة الجديدة
+                    new_material = pd.DataFrame({
+                        "رقم المادة": [new_material_id],
+                        "اسم المادة": [new_material_name],
+                        "الوحدة": [new_material_unit],
+                        "الكمية المتاحة": [new_material_quantity],
+                        "تكلفة الوحدة": [new_material_cost],
+                        "المورد": [new_material_supplier],
+                        "مدة التوريد (يوم)": [new_material_lead_time]
+                    })
+                    
+                    # تحديث DataFrame المواد
+                    st.session_state.resources_data["materials"] = pd.concat([materials_df, new_material], ignore_index=True)
+                    
+                    st.success(f"تم إضافة المادة {new_material_name} بنجاح!")
+                    st.rerun()
+                else:
+                    st.error("يرجى إدخال اسم المادة")
+        
+        # طلب مواد
+        st.markdown("#### طلب مواد")
+        
+        with st.form("order_materials_form"):
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                material_to_order = st.selectbox("المادة", options=materials_df["اسم المادة"].unique())
+            
+            with col2:
+                order_quantity = st.number_input("الكمية المطلوبة", min_value=1, max_value=1000, value=50)
+            
+            with col3:
+                order_date = st.date_input("تاريخ الطلب", value=datetime.now())
+            
+            submit_button = st.form_submit_button("طلب المادة")
+            
+            if submit_button:
+                # محاكاة طلب المادة
+                st.success(f"تم طلب {order_quantity} {materials_df[materials_df['اسم المادة'] == material_to_order]['الوحدة'].values[0]} من {material_to_order} بنجاح!")
+                
+                # عرض تفاصيل الطلب
+                material_info = materials_df[materials_df["اسم المادة"] == material_to_order].iloc[0]
+                lead_time = material_info["مدة التوريد (يوم)"]
+                expected_delivery = order_date + timedelta(days=lead_time)
+                
+                st.info(f"تاريخ التسليم المتوقع: {expected_delivery.strftime('%Y-%m-%d')}")
+                
+                # حساب التكلفة الإجمالية
+                unit_cost = material_info["تكلفة الوحدة"]
+                total_cost = unit_cost * order_quantity
+                
+                st.metric("التكلفة الإجمالية", f"{total_cost:,.2f} ريال")
+    
+    def _render_resource_allocation_tab(self):
+        """عرض تبويب تخصيص الموارد"""
+        
+        st.markdown("### تخصيص الموارد")
+        
+        # استخراج البيانات
+        employees_df = st.session_state.resources_data["employees"]
+        equipment_df = st.session_state.resources_data["equipment"]
+        materials_df = st.session_state.resources_data["materials"]
+        projects_df = st.session_state.resources_data["projects"]
+        allocations_df = st.session_state.resources_data["allocations"]
+        
+        # عرض خيارات التصفية
+        st.markdown("#### خيارات التصفية")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            selected_projects = st.multiselect(
+                "المشروع",
+                options=projects_df["اسم المشروع"].unique(),
+                default=projects_df["اسم المشروع"].unique()
+            )
+        
+        with col2:
+            selected_resource_types = st.multiselect(
+                "نوع المورد",
+                options=allocations_df["نوع المورد"].unique(),
+                default=allocations_df["نوع المورد"].unique()
+            )
+        
+        # تحويل أسماء المشاريع إلى أرقام المشاريع
+        selected_project_ids = projects_df[projects_df["اسم المشروع"].isin(selected_projects)]["رقم المشروع"].tolist()
+        
+        # تطبيق التصفية
+        filtered_df = allocations_df[
+            allocations_df["رقم المشروع"].isin(selected_project_ids) &
+            allocations_df["نوع المورد"].isin(selected_resource_types)
+        ]
+        
+        # دمج البيانات مع بيانات المشاريع
+        merged_df = filtered_df.merge(
+            projects_df[["رقم المشروع", "اسم المشروع"]],
+            on="رقم المشروع",
+            how="left"
+        )
+        
+        # إضافة أسماء الموارد
+        merged_df["اسم المورد"] = ""
+        
+        for i, row in merged_df.iterrows():
+            if row["نوع المورد"] == "موظف":
+                resource_name = employees_df[employees_df["رقم الموظف"] == row["رقم المورد"]]["اسم الموظف"].values
+                if len(resource_name) > 0:
+                    merged_df.at[i, "اسم المورد"] = resource_name[0]
+            elif row["نوع المورد"] == "معدة":
+                resource_name = equipment_df[equipment_df["رقم المعدة"] == row["رقم المورد"]]["اسم المعدة"].values
+                if len(resource_name) > 0:
+                    merged_df.at[i, "اسم المورد"] = resource_name[0]
+            elif row["نوع المورد"] == "مادة":
+                resource_name = materials_df[materials_df["رقم المادة"] == row["رقم المورد"]]["اسم المادة"].values
+                if len(resource_name) > 0:
+                    merged_df.at[i, "اسم المورد"] = resource_name[0]
+        
+        # عرض البيانات المصفاة
+        st.markdown("#### قائمة تخصيص الموارد")
+        
+        display_df = merged_df[["رقم التخصيص", "اسم المشروع", "نوع المورد", "اسم المورد", "تاريخ البدء", "تاريخ الانتهاء", "الكمية", "التكلفة"]]
+        
+        st.dataframe(
+            display_df,
+            column_config={
+                "رقم التخصيص": st.column_config.TextColumn("رقم التخصيص"),
+                "اسم المشروع": st.column_config.TextColumn("اسم المشروع"),
+                "نوع المورد": st.column_config.TextColumn("نوع المورد"),
+                "اسم المورد": st.column_config.TextColumn("اسم المورد"),
+                "تاريخ البدء": st.column_config.DateColumn("تاريخ البدء"),
+                "تاريخ الانتهاء": st.column_config.DateColumn("تاريخ الانتهاء"),
+                "الكمية": st.column_config.NumberColumn("الكمية"),
+                "التكلفة": st.column_config.NumberColumn("التكلفة", format="%.2f ريال")
+            },
+            use_container_width=True,
+            hide_index=True
+        )
+        
+        # عرض إحصائيات تخصيص الموارد
+        st.markdown("#### إحصائيات تخصيص الموارد")
+        
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            total_allocations = len(merged_df)
+            st.metric("إجمالي التخصيصات", f"{total_allocations}")
+        
+        with col2:
+            total_cost = merged_df["التكلفة"].sum()
+            st.metric("إجمالي التكلفة", f"{total_cost:,.0f} ريال")
+        
+        with col3:
+            avg_duration = (pd.to_datetime(merged_df["تاريخ الانتهاء"]) - pd.to_datetime(merged_df["تاريخ البدء"])).mean().days
+            st.metric("متوسط مدة التخصيص", f"{avg_duration:.0f} يوم")
+        
+        with col4:
+            resource_types = merged_df["نوع المورد"].value_counts()
+            most_common_type = resource_types.index[0] if not resource_types.empty else ""
+            st.metric("أكثر أنواع الموارد تخصيصاً", f"{most_common_type}")
+        
+        # عرض توزيع تخصيص الموارد حسب المشروع
+        st.markdown("#### توزيع تخصيص الموارد حسب المشروع")
+        
+        project_allocations = merged_df.groupby("اسم المشروع").size().reset_index()
+        project_allocations.columns = ["اسم المشروع", "عدد التخصيصات"]
+        
+        fig = px.bar(
+            project_allocations,
+            x="اسم المشروع",
+            y="عدد التخصيصات",
+            title="توزيع تخصيص الموارد حسب المشروع",
+            color="اسم المشروع",
+            text_auto=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع تخصيص الموارد حسب نوع المورد
+        st.markdown("#### توزيع تخصيص الموارد حسب نوع المورد")
+        
+        resource_type_allocations = merged_df.groupby("نوع المورد").size().reset_index()
+        resource_type_allocations.columns = ["نوع المورد", "عدد التخصيصات"]
+        
+        fig = px.pie(
+            resource_type_allocations,
+            values="عدد التخصيصات",
+            names="نوع المورد",
+            title="توزيع تخصيص الموارد حسب نوع المورد",
+            color="نوع المورد",
+            color_discrete_map={
+                "موظف": "#3498db",
+                "معدة": "#2ecc71",
+                "مادة": "#f39c12"
+            }
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع تكاليف الموارد حسب المشروع
+        st.markdown("#### توزيع تكاليف الموارد حسب المشروع")
+        
+        project_costs = merged_df.groupby("اسم المشروع")["التكلفة"].sum().reset_index()
+        project_costs.columns = ["اسم المشروع", "إجمالي التكلفة"]
+        
+        fig = px.bar(
+            project_costs,
+            x="اسم المشروع",
+            y="إجمالي التكلفة",
+            title="توزيع تكاليف الموارد حسب المشروع",
+            color="اسم المشروع",
+            text_auto=".0f"
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توزيع تكاليف الموارد حسب نوع المورد
+        st.markdown("#### توزيع تكاليف الموارد حسب نوع المورد")
+        
+        resource_type_costs = merged_df.groupby("نوع المورد")["التكلفة"].sum().reset_index()
+        resource_type_costs.columns = ["نوع المورد", "إجمالي التكلفة"]
+        
+        fig = px.pie(
+            resource_type_costs,
+            values="إجمالي التكلفة",
+            names="نوع المورد",
+            title="توزيع تكاليف الموارد حسب نوع المورد",
+            color="نوع المورد",
+            color_discrete_map={
+                "موظف": "#3498db",
+                "معدة": "#2ecc71",
+                "مادة": "#f39c12"
+            }
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # إضافة تخصيص جديد
+        st.markdown("#### إضافة تخصيص جديد")
+        
+        with st.form("add_allocation_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                new_allocation_project = st.selectbox("المشروع", options=projects_df["اسم المشروع"].unique())
+                new_allocation_resource_type = st.selectbox("نوع المورد", options=["موظف", "معدة", "ما��ة"])
+                
+                # تحديد خيارات الموارد بناءً على النوع
+                if new_allocation_resource_type == "موظف":
+                    resource_options = employees_df[employees_df["متاح"] == True]["اسم الموظف"].unique()
+                elif new_allocation_resource_type == "معدة":
+                    resource_options = equipment_df[equipment_df["متاحة"] == True]["اسم المعدة"].unique()
+                else:
+                    resource_options = materials_df["اسم المادة"].unique()
+                
+                new_allocation_resource = st.selectbox("المورد", options=resource_options)
+            
+            with col2:
+                new_allocation_start_date = st.date_input("تاريخ البدء", value=datetime.now())
+                new_allocation_end_date = st.date_input("تاريخ الانتهاء", value=datetime.now() + timedelta(days=30))
+                new_allocation_quantity = st.number_input("الكمية", min_value=1, max_value=100, value=1)
+            
+            submit_button = st.form_submit_button("إضافة تخصيص")
+            
+            if submit_button:
+                # التحقق من صحة التواريخ
+                if new_allocation_end_date <= new_allocation_start_date:
+                    st.error("يجب أن يكون تاريخ الانتهاء بعد تاريخ البدء")
+                else:
+                    # الحصول على رقم المشروع
+                    project_id = projects_df[projects_df["اسم المشروع"] == new_allocation_project]["رقم المشروع"].values[0]
+                    
+                    # الحصول على رقم المورد
+                    if new_allocation_resource_type == "موظف":
+                        resource_id = employees_df[employees_df["اسم الموظف"] == new_allocation_resource]["رقم الموظف"].values[0]
+                        # حساب التكلفة
+                        cost = employees_df[employees_df["رقم الموظف"] == resource_id]["التكلفة الشهرية"].values[0] * new_allocation_quantity
+                    elif new_allocation_resource_type == "معدة":
+                        resource_id = equipment_df[equipment_df["اسم المعدة"] == new_allocation_resource]["رقم المعدة"].values[0]
+                        # حساب التكلفة
+                        days = (new_allocation_end_date - new_allocation_start_date).days
+                        cost = equipment_df[equipment_df["رقم المعدة"] == resource_id]["التكلفة اليومية"].values[0] * days * new_allocation_quantity
+                    else:
+                        resource_id = materials_df[materials_df["اسم المادة"] == new_allocation_resource]["رقم المادة"].values[0]
+                        # حساب التكلفة
+                        cost = materials_df[materials_df["رقم المادة"] == resource_id]["تكلفة الوحدة"].values[0] * new_allocation_quantity
+                    
+                    # إنشاء رقم تخصيص جديد
+                    new_allocation_id = f"ALLOC-{len(allocations_df) + 1:03d}"
+                    
+                    # إضافة التخصيص الجديد
+                    new_allocation = pd.DataFrame({
+                        "رقم التخصيص": [new_allocation_id],
+                        "رقم المشروع": [project_id],
+                        "نوع المورد": [new_allocation_resource_type],
+                        "رقم المورد": [resource_id],
+                        "تاريخ البدء": [new_allocation_start_date.strftime("%Y-%m-%d")],
+                        "تاريخ الانتهاء": [new_allocation_end_date.strftime("%Y-%m-%d")],
+                        "الكمية": [new_allocation_quantity],
+                        "التكلفة": [cost]
+                    })
+                    
+                    # تحديث DataFrame التخصيصات
+                    st.session_state.resources_data["allocations"] = pd.concat([allocations_df, new_allocation], ignore_index=True)
+                    
+                    # تحديث حالة المورد إذا كان موظف أو معدة
+                    if new_allocation_resource_type == "موظف":
+                        employees_idx = employees_df[employees_df["رقم الموظف"] == resource_id].index
+                        st.session_state.resources_data["employees"].at[employees_idx[0], "متاح"] = False
+                    elif new_allocation_resource_type == "معدة":
+                        equipment_idx = equipment_df[equipment_df["رقم المعدة"] == resource_id].index
+                        st.session_state.resources_data["equipment"].at[equipment_idx[0], "متاحة"] = False
+                    elif new_allocation_resource_type == "مادة":
+                        materials_idx = materials_df[materials_df["رقم المادة"] == resource_id].index
+                        current_quantity = st.session_state.resources_data["materials"].at[materials_idx[0], "الكمية المتاحة"]
+                        st.session_state.resources_data["materials"].at[materials_idx[0], "الكمية المتاحة"] = max(0, current_quantity - new_allocation_quantity)
+                    
+                    st.success(f"تم إضافة تخصيص {new_allocation_resource_type} ({new_allocation_resource}) لمشروع {new_allocation_project} بنجاح!")
+                    st.rerun()
+    
+    def _render_resource_planning_tab(self):
+        """عرض تبويب تخطيط الموارد"""
+        
+        st.markdown("### تخطيط الموارد")
+        
+        # استخراج البيانات
+        employees_df = st.session_state.resources_data["employees"]
+        equipment_df = st.session_state.resources_data["equipment"]
+        materials_df = st.session_state.resources_data["materials"]
+        projects_df = st.session_state.resources_data["projects"]
+        allocations_df = st.session_state.resources_data["allocations"]
+        
+        # عرض المشاريع القادمة
+        st.markdown("#### المشاريع القادمة")
+        
+        upcoming_projects = projects_df[projects_df["الحالة"] == "مخطط"].sort_values("تاريخ البدء")
+        
+        if not upcoming_projects.empty:
+            st.dataframe(
+                upcoming_projects,
+                column_config={
+                    "رقم المشروع": st.column_config.TextColumn("رقم المشروع"),
+                    "اسم المشروع": st.column_config.TextColumn("اسم المشروع"),
+                    "الموقع": st.column_config.TextColumn("الموقع"),
+                    "تاريخ البدء": st.column_config.DateColumn("تاريخ البدء"),
+                    "تاريخ الانتهاء": st.column_config.DateColumn("تاريخ الانتهاء"),
+                    "الميزانية": st.column_config.NumberColumn("الميزانية", format="%.2f ريال"),
+                    "الحالة": st.column_config.TextColumn("الحالة")
+                },
+                use_container_width=True,
+                hide_index=True
+            )
+        else:
+            st.info("لا توجد مشاريع قادمة")
+        
+        # عرض توافر الموارد
+        st.markdown("#### توافر الموارد")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            total_employees = len(employees_df)
+            available_employees = len(employees_df[employees_df["متاح"] == True])
+            availability_rate = available_employees / total_employees * 100 if total_employees > 0 else 0
+            
+            st.metric("الموظفون المتاحون", f"{available_employees}/{total_employees}", f"{availability_rate:.1f}%")
+            
+            # عرض توزيع توافر الموظفين
+            availability_data = pd.DataFrame({
+                "الحالة": ["متاح", "غير متاح"],
+                "العدد": [available_employees, total_employees - available_employees]
+            })
+            
+            fig = px.pie(
+                availability_data,
+                values="العدد",
+                names="الحالة",
+                title="توافر الموظفين",
+                color="الحالة",
+                color_discrete_map={
+                    "متاح": "#2ecc71",
+                    "غير متاح": "#e74c3c"
+                }
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            total_equipment = len(equipment_df)
+            available_equipment = len(equipment_df[equipment_df["متاحة"] == True])
+            availability_rate = available_equipment / total_equipment * 100 if total_equipment > 0 else 0
+            
+            st.metric("المعدات المتاحة", f"{available_equipment}/{total_equipment}", f"{availability_rate:.1f}%")
+            
+            # عرض توزيع توافر المعدات
+            availability_data = pd.DataFrame({
+                "الحالة": ["متاحة", "غير متاحة"],
+                "العدد": [available_equipment, total_equipment - available_equipment]
+            })
+            
+            fig = px.pie(
+                availability_data,
+                values="العدد",
+                names="الحالة",
+                title="توافر المعدات",
+                color="الحالة",
+                color_discrete_map={
+                    "متاحة": "#2ecc71",
+                    "غير متاحة": "#e74c3c"
+                }
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col3:
+            total_materials = len(materials_df)
+            low_stock_materials = len(materials_df[materials_df["الكمية المتاحة"] < 50])
+            low_stock_rate = low_stock_materials / total_materials * 100 if total_materials > 0 else 0
+            
+            st.metric("المواد منخفضة المخزون", f"{low_stock_materials}/{total_materials}", f"{low_stock_rate:.1f}%")
+            
+            # عرض توزيع حالة المخزون
+            stock_data = pd.DataFrame({
+                "حالة المخزون": ["مخزون كافي", "مخزون منخفض"],
+                "العدد": [total_materials - low_stock_materials, low_stock_materials]
+            })
+            
+            fig = px.pie(
+                stock_data,
+                values="العدد",
+                names="حالة المخزون",
+                title="حالة مخزون المواد",
+                color="حالة المخزون",
+                color_discrete_map={
+                    "مخزون كافي": "#2ecc71",
+                    "مخزون منخفض": "#e74c3c"
+                }
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض جدول زمني للموارد
+        st.markdown("#### الجدول الزمني للموارد")
+        
+        # إنشاء DataFrame للجدول الزمني
+        timeline_df = allocations_df.copy()
+        timeline_df["تاريخ البدء"] = pd.to_datetime(timeline_df["تاريخ البدء"])
+        timeline_df["تاريخ الانتهاء"] = pd.to_datetime(timeline_df["تاريخ الانتهاء"])
+        
+        # دمج البيانات مع بيانات المشاريع
+        timeline_df = timeline_df.merge(
+            projects_df[["رقم المشروع", "اسم المشروع"]],
+            on="رقم المشروع",
+            how="left"
+        )
+        
+        # إضافة أسماء الموارد
+        timeline_df["اسم المورد"] = ""
+        
+        for i, row in timeline_df.iterrows():
+            if row["نوع المورد"] == "موظف":
+                resource_name = employees_df[employees_df["رقم الموظف"] == row["رقم المورد"]]["اسم الموظف"].values
+                if len(resource_name) > 0:
+                    timeline_df.at[i, "اسم المورد"] = resource_name[0]
+            elif row["نوع المورد"] == "معدة":
+                resource_name = equipment_df[equipment_df["رقم المعدة"] == row["رقم المورد"]]["اسم المعدة"].values
+                if len(resource_name) > 0:
+                    timeline_df.at[i, "اسم المورد"] = resource_name[0]
+            elif row["نوع المورد"] == "مادة":
+                resource_name = materials_df[materials_df["رقم المادة"] == row["رقم المورد"]]["اسم المادة"].values
+                if len(resource_name) > 0:
+                    timeline_df.at[i, "اسم المورد"] = resource_name[0]
+        
+        # إنشاء رسم بياني للجدول الزمني
+        fig = px.timeline(
+            timeline_df,
+            x_start="تاريخ البدء",
+            x_end="تاريخ الانتهاء",
+            y="اسم المورد",
+            color="اسم المشروع",
+            hover_name="اسم المشروع",
+            hover_data=["نوع المورد", "الكمية", "التكلفة"],
+            title="الجدول الزمني لتخصيص الموارد"
+        )
+        
+        fig.update_yaxes(autorange="reversed")
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # عرض توقعات الاحتياجات المستقبلية
+        st.markdown("#### توقعات الاحتياجات المستقبلية")
+        
+        # اختيار المشروع للتخطيط
+        project_for_planning = st.selectbox("اختر المشروع للتخطيط", options=upcoming_projects["اسم المشروع"] if not upcoming_projects.empty else ["لا توجد مشاريع قادمة"])
+        
+        if project_for_planning != "لا توجد مشاريع قادمة":
+            # الحصول على بيانات المشروع
+            project_data = upcoming_projects[upcoming_projects["اسم المشروع"] == project_for_planning].iloc[0]
+            
+            st.markdown(f"**تاريخ البدء:** {project_data['تاريخ البدء']}")
+            st.markdown(f"**تاريخ الانتهاء:** {project_data['تاريخ الانتهاء']}")
+            st.markdown(f"**الميزانية:** {project_data['الميزانية']:,.0f} ريال")
+            
+            # تقدير الاحتياجات بناءً على المشاريع المماثلة
+            st.markdown("##### تقدير الاحتياجات بناءً على المشاريع المماثلة")
+            
+            # محاكاة تقدير الاحتياجات
+            estimated_resources = {
+                "الموظ��ون": {
+                    "مهندس": 5,
+                    "فني": 10,
+                    "مشرف": 2,
+                    "محاسب": 1,
+                    "مساعد": 3
+                },
+                "المعدات": {
+                    "حفارة كبيرة": 1,
+                    "حفارة صغيرة": 2,
+                    "شاحنة نقل": 3,
+                    "رافعة متوسطة": 1,
+                    "خلاطة خرسانة": 2
+                },
+                "المواد": {
+                    "خرسانة جاهزة": 500,
+                    "حديد تسليح": 200,
+                    "طابوق": 10000,
+                    "أسمنت": 1000,
+                    "رمل": 300
+                }
+            }
+            
+            # عرض تقدير الاحتياجات
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                st.markdown("**الموظفون المطلوبون:**")
+                for position, count in estimated_resources["الموظفون"].items():
+                    st.markdown(f"- {position}: {count}")
+                
+                # التحقق من توافر الموظفين
+                available_positions = {}
+                for position, count in estimated_resources["الموظفون"].items():
+                    available_count = len(employees_df[(employees_df["المنصب"] == position) & (employees_df["متاح"] == True)])
+                    available_positions[position] = available_count
+                    
+                    if available_count < count:
+                        st.warning(f"نقص في {position}: متاح {available_count}/{count}")
+                    else:
+                        st.success(f"متوفر: {available_count}/{count}")
+            
+            with col2:
+                st.markdown("**المعدات المطلوبة:**")
+                for equipment_name, count in estimated_resources["المعدات"].items():
+                    st.markdown(f"- {equipment_name}: {count}")
+                
+                # التحقق من توافر المعدات
+                available_equipment = {}
+                for equipment_name, count in estimated_resources["المعدات"].items():
+                    available_count = len(equipment_df[(equipment_df["اسم المعدة"] == equipment_name) & (equipment_df["متاحة"] == True)])
+                    available_equipment[equipment_name] = available_count
+                    
+                    if available_count < count:
+                        st.warning(f"نقص في {equipment_name}: متاح {available_count}/{count}")
+                    else:
+                        st.success(f"متوفر: {available_count}/{count}")
+            
+            with col3:
+                st.markdown("**المواد المطلوبة:**")
+                for material_name, quantity in estimated_resources["المواد"].items():
+                    st.markdown(f"- {material_name}: {quantity}")
+                
+                # التحقق من توافر المواد
+                available_materials = {}
+                for material_name, quantity in estimated_resources["المواد"].items():
+                    available_quantity = materials_df[materials_df["اسم المادة"] == material_name]["الكمية المتاحة"].sum()
+                    available_materials[material_name] = available_quantity
+                    
+                    if available_quantity < quantity:
+                        st.warning(f"نقص في {material_name}: متاح {available_quantity}/{quantity}")
+                    else:
+                        st.success(f"متوفر: {available_quantity}/{quantity}")
+            
+            # عرض تقدير التكاليف
+            st.markdown("##### تقدير تكاليف الموارد")
+            
+            # حساب تكاليف الموظفين
+            employee_costs = 0
+            for position, count in estimated_resources["الموظفون"].items():
+                avg_cost = employees_df[employees_df["المنصب"] == position]["التكلفة الشهرية"].mean()
+                # افتراض مدة المشروع 6 أشهر
+                employee_costs += avg_cost * count * 6
+            
+            # حساب تكاليف المعدات
+            equipment_costs = 0
+            for equipment_name, count in estimated_resources["المعدات"].items():
+                avg_cost = equipment_df[equipment_df["اسم المعدة"] == equipment_name]["التكلفة اليومية"].mean()
+                # افتراض مدة المشروع 180 يوم
+                equipment_costs += avg_cost * count * 180
+            
+            # حساب تكاليف المواد
+            material_costs = 0
+            for material_name, quantity in estimated_resources["المواد"].items():
+                avg_cost = materials_df[materials_df["ا��م المادة"] == material_name]["تكلفة الوحدة"].mean()
+                material_costs += avg_cost * quantity
+            
+            # إجمالي التكاليف
+            total_costs = employee_costs + equipment_costs + material_costs
+            
+            # عرض التكاليف
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                st.metric("تكاليف الموظفين", f"{employee_costs:,.0f} ريال")
+            
+            with col2:
+                st.metric("تكاليف المعدات", f"{equipment_costs:,.0f} ريال")
+            
+            with col3:
+                st.metric("تكاليف المواد", f"{material_costs:,.0f} ريال")
+            
+            with col4:
+                st.metric("إجمالي التكاليف", f"{total_costs:,.0f} ريال")
+            
+            # عرض توزيع التكاليف
+            cost_distribution = pd.DataFrame({
+                "نوع التكلفة": ["تكاليف الموظفين", "تكاليف المعدات", "تكاليف المواد"],
+                "التكلفة": [employee_costs, equipment_costs, material_costs]
+            })
+            
+            fig = px.pie(
+                cost_distribution,
+                values="التكلفة",
+                names="نوع التكلفة",
+                title="توزيع تكاليف الموارد",
+                color="نوع التكلفة",
+                color_discrete_map={
+                    "تكاليف الموظفين": "#3498db",
+                    "تكاليف المعدات": "#2ecc71",
+                    "تكاليف المواد": "#f39c12"
+                }
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # عرض توصيات لتخطيط الموارد
+            st.markdown("##### توصيات لتخطيط الموارد")
+            
+            recommendations = []
+            
+            # توصيات للموظفين
+            for position, count in estimated_resources["الموظفون"].items():
+                available_count = available_positions[position]
+                if available_count < count:
+                    recommendations.append(f"توظيف {count - available_count} {position} إضافي")
+            
+            # توصيات للمعدات
+            for equipment_name, count in estimated_resources["المعدات"].items():
+                available_count = available_equipment[equipment_name]
+                if available_count < count:
+                    recommendations.append(f"استئجار {count - available_count} {equipment_name} إضافية")
+            
+            # توصيات للمواد
+            for material_name, quantity in estimated_resources["المواد"].items():
+                available_quantity = available_materials[material_name]
+                if available_quantity < quantity:
+                    recommendations.append(f"شراء {quantity - available_quantity} وحدة إضافية من {material_name}")
+            
+            if recommendations:
+                for recommendation in recommendations:
+                    st.markdown(f"- {recommendation}")
+            else:
+                st.success("جميع الموارد المطلوبة متوفرة")
+            
+            # زر لإنشاء خطة الموارد
+            if st.button("إنشاء خطة الموارد"):
+                st.success("تم إنشاء خطة الموارد بنجاح!")
+                
+                # عرض ملخص الخطة
+                st.markdown("##### ملخص خطة الموارد")
+                st.markdown(f"**المشروع:** {project_for_planning}")
+                st.markdown(f"**تاريخ البدء:** {project_data['تاريخ البدء']}")
+                st.markdown(f"**تاريخ الانتهاء:** {project_data['تاريخ الانتهاء']}")
+                st.markdown(f"**إجمالي تكاليف الموارد:** {total_costs:,.0f} ريال")
+                st.markdown(f"**نسبة تكاليف الموارد من الميزانية:** {total_costs / project_data['الميزانية'] * 100:.1f}%")
+                
+                if recommendations:
+                    st.markdown("**الإجراءات المطلوبة:**")
+                    for recommendation in recommendations:
+                        st.markdown(f"- {recommendation}")
+                else:
+                    st.markdown("**الإجراءات المطلوبة:** لا توجد إجراءات مطلوبة، جميع الموارد متوفرة")
+        else:
+            st.info("لا توجد مشاريع قادمة للتخطيط")

modules/risk_analysis/risk_analyzer.py

@@ -0,0 +1,1154 @@
+"""
+وحدة تحليل المخاطر لنظام إدارة المناقصات - Hybrid Face
+"""
+
+import os
+import logging
+import threading
+import datetime
+import json
+import math
+import streamlit as st
+from pathlib import Path
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import sys
+
+# إضافة مسار المشروع للنظام
+sys.path.append(str(Path(__file__).parent.parent))
+
+# استيراد محسن واجهة المستخدم
+from styling.enhanced_ui import UIEnhancer
+
+# تهيئة السجل
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger('risk_analysis')
+
+class RiskAnalyzer:
+    """محلل المخاطر"""
+    
+    def __init__(self, config=None, db=None):
+        """تهيئة محلل المخاطر"""
+        self.config = config
+        self.db = db
+        self.analysis_in_progress = False
+        self.current_project = None
+        self.analysis_results = {}
+        
+        # إنشاء مجلد التحليل إذا لم يكن موجوداً
+        if config and hasattr(config, 'EXPORTS_PATH'):
+            self.exports_path = Path(config.EXPORTS_PATH)
+        else:
+            self.exports_path = Path('data/exports')
+            
+        if not self.exports_path.exists():
+            self.exports_path.mkdir(parents=True, exist_ok=True)
+    
+    def analyze_risks(self, project_id, method="comprehensive", callback=None):
+        """تحليل مخاطر المشروع"""
+        if self.analysis_in_progress:
+            logger.warning("هناك عملية تحليل مخاطر جارية بالفعل")
+            return False
+        
+        self.analysis_in_progress = True
+        self.current_project = project_id
+        self.analysis_results = {
+            "project_id": project_id,
+            "method": method,
+            "analysis_start_time": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+            "status": "جاري التحليل",
+            "identified_risks": [],
+            "risk_categories": {},
+            "risk_matrix": {},
+            "mitigation_strategies": [],
+            "summary": {}
+        }
+        
+        # بدء التحليل في خيط منفصل
+        thread = threading.Thread(
+            target=self._analyze_risks_thread,
+            args=(project_id, method, callback)
+        )
+        thread.daemon = True
+        thread.start()
+        
+        return True
+    
+    def _analyze_risks_thread(self, project_id, method, callback):
+        """خيط تحليل المخاطر"""
+        try:
+            # محاكاة جلب بيانات المشروع من قاعدة البيانات
+            project_data = self._get_project_data(project_id)
+            
+            if not project_data:
+                logger.error(f"لم يتم العثور على بيانات المشروع: {project_id}")
+                self.analysis_results["status"] = "فشل التحليل"
+                self.analysis_results["error"] = "لم يتم العثور على بيانات المشروع"
+                return
+            
+            # تحديد المخاطر
+            self._identify_risks(project_data, method)
+            
+            # تصنيف المخاطر
+            self._categorize_risks()
+            
+            # إنشاء مصفوفة المخاطر
+            self._create_risk_matrix()
+            
+            # تطوير استراتيجيات التخفيف
+            self._develop_mitigation_strategies(method)
+            
+            # إنشاء ملخص التحليل
+            self._create_analysis_summary(method)
+            
+            # تحديث حالة التحليل
+            self.analysis_results["status"] = "اكتمل التحليل"
+            self.analysis_results["analysis_end_time"] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            
+            logger.info(f"اكتمل تحليل مخاطر المشروع: {project_id}")
+            
+        except Exception as e:
+            logger.error(f"خطأ في تحليل مخاطر المشروع: {str(e)}")
+            self.analysis_results["status"] = "فشل التحليل"
+            self.analysis_results["error"] = str(e)
+        
+        finally:
+            self.analysis_in_progress = False
+            
+            # استدعاء دالة الاستجابة إذا تم توفيرها
+            if callback and callable(callback):
+                callback(self.analysis_results)
+    
+    def _get_project_data(self, project_id):
+        """الحصول على بيانات المشروع"""
+        # في التطبيق الفعلي، سيتم جلب البيانات من قاعدة البيانات
+        # هنا نقوم بمحاكاة البيانات للتوضيح
+        
+        return {
+            "id": project_id,
+            "name": "مشروع الطرق السريعة",
+            "client": "وزارة النقل",
+            "description": "إنشاء طرق سريعة بطول 50 كم في المنطقة الشرقية",
+            "start_date": "2025-05-01",
+            "end_date": "2025-11-30",
+            "status": "تخطيط",
+            "budget": 50000000,
+            "location": "المنطقة الشرقية",
+            "project_type": "بنية تحتية",
+            "complexity": "متوسط",
+            "existing_risks": [
+                {"id": 1, "name": "تأخر توريد المواد", "probability": "متوسط", "impact": "عالي", "category": "توريد"},
+                {"id": 2, "name": "تغير أسعار المواد", "probability": "عالي", "impact": "عالي", "category": "مالي"},
+                {"id": 3, "name": "ظروف جوية غير مواتية", "probability": "منخفض", "impact": "متوسط", "category": "بيئي"},
+                {"id": 4, "name": "نقص العمالة", "probability": "متوسط", "impact": "متوسط", "category": "موارد بشرية"}
+            ]
+        }
+    
+    def _identify_risks(self, project_data, method):
+        """تحديد المخاطر"""
+        # دمج المخاطر الموجودة
+        identified_risks = []
+        for risk in project_data["existing_risks"]:
+            identified_risks.append({
+                "id": risk["id"],
+                "name": risk["name"],
+                "description": f"مخاطر {risk['name']} في المشروع",
+                "category": risk["category"],
+                "probability": risk["probability"],
+                "impact": risk["impact"],
+                "risk_score": self._calculate_risk_score(risk["probability"], risk["impact"]),
+                "source": "existing"
+            })
+        
+        # إضافة مخاطر إضافية بناءً على نوع المشروع وموقعه وتعقيده
+        additional_risks = self._generate_additional_risks(project_data, method)
+        identified_risks.extend(additional_risks)
+        
+        # تخزين المخاطر المحددة
+        self.analysis_results["identified_risks"] = identified_risks
+    
+    def _generate_additional_risks(self, project_data, method):
+        """توليد مخاطر إضافية بناءً على بيانات المشروع"""
+        additional_risks = []
+        
+        # مخاطر مرتبطة بنوع المشروع
+        if project_data["project_type"] == "بنية تحتية":
+            additional_risks.extend([
+                {
+                    "id": 101,
+                    "name": "مشاكل جيوتقنية",
+                    "description": "مشاكل غير متوقعة في التربة أو الظروف الجيولوجية",
+                    "category": "فني",
+                    "probability": "متوسط",
+                    "impact": "عالي",
+                    "risk_score": self._calculate_risk_score("متوسط", "عالي"),
+                    "source": "generated"
+                },
+                {
+                    "id": 102,
+                    "name": "تعارض مع مرافق قائمة",
+                    "description": "تعارض أعمال الحفر مع خطوط المرافق القائمة (كهرباء، مياه، اتصالات)",
+                    "category": "فني",
+                    "probability": "متوسط",
+                    "impact": "متوسط",
+                    "risk_score": self._calculate_risk_score("متوسط", "متوسط"),
+                    "source": "generated"
+                }
+            ])
+        
+        # مخاطر مرتبطة بالموقع
+        if project_data["location"] == "المنطقة الشرقية":
+            additional_risks.extend([
+                {
+                    "id": 201,
+                    "name": "ارتفاع درجات الحرارة",
+                    "description": "تأثير ارتفاع درجات الحرارة على إنتاجية العمل وجودة المواد",
+                    "category": "بيئي",
+                    "probability": "عالي",
+                    "impact": "متوسط",
+                    "risk_score": self._calculate_risk_score("عالي", "متوسط"),
+                    "source": "generated"
+                },
+                {
+                    "id": 202,
+                    "name": "رطوبة عالية",
+                    "description": "تأثير الرطوبة العالية على جودة المواد وتقنيات البناء",
+                    "category": "بيئي",
+                    "probability": "عالي",
+                    "impact": "منخفض",
+                    "risk_score": self._calculate_risk_score("عالي", "منخفض"),
+                    "source": "generated"
+                }
+            ])
+        
+        # مخاطر مرتبطة بتعقيد المشروع
+        if project_data["complexity"] in ["متوسط", "عالي"]:
+            additional_risks.extend([
+                {
+                    "id": 301,
+                    "name": "تغييرات في نطاق العمل",
+                    "description": "طلبات تغيير من العميل أو تعديلات في متطلبات المشروع",
+                    "category": "إداري",
+                    "probability": "عالي",
+                    "impact": "عالي",
+                    "risk_score": self._calculate_risk_score("عالي", "عالي"),
+                    "source": "generated"
+                },
+                {
+                    "id": 302,
+                    "name": "تأخر الموافقات",
+                    "description": "تأخر الحصول على الموافقات والتصاريح اللازمة",
+                    "category": "تنظيمي",
+                    "probability": "متوسط",
+                    "impact": "عالي",
+                    "risk_score": self._calculate_risk_score("متوسط", "عالي"),
+                    "source": "generated"
+                }
+            ])
+        
+        # إضافة مخاطر إضافية إذا كانت طريقة التحليل شاملة
+        if method == "comprehensive":
+            additional_risks.extend([
+                {
+                    "id": 401,
+                    "name": "مخاطر سياسية",
+                    "description": "تغييرات في السياسات الحكومية أو اللوائح التنظيمية",
+                    "category": "خارجي",
+                    "probability": "منخفض",
+                    "impact": "عالي",
+                    "risk_score": self._calculate_risk_score("منخفض", "عالي"),
+                    "source": "generated"
+                },
+                {
+                    "id": 402,
+                    "name": "مخاطر اقتصادية",
+                    "description": "تقلبات في أسعار العملات أو التضخم",
+                    "category": "مالي",
+                    "probability": "متوسط",
+                    "impact": "متوسط",
+                    "risk_score": self._calculate_risk_score("متوسط", "متوسط"),
+                    "source": "generated"
+                },
+                {
+                    "id": 403,
+                    "name": "مخاطر تقنية",
+                    "description": "مشاكل في التقنيات الجديدة أو المعدات",
+                    "category": "فني",
+                    "probability": "متوسط",
+                    "impact": "متوسط",
+                    "risk_score": self._calculate_risk_score("متوسط", "متوسط"),
+                    "source": "generated"
+                }
+            ])
+        
+        return additional_risks
+    
+    def _calculate_risk_score(self, probability, impact):
+        """حساب درجة المخاطرة"""
+        # تحويل القيم النصية إلى قيم رقمية
+        probability_values = {"منخفض": 1, "متوسط": 2, "عالي": 3}
+        impact_values = {"منخفض": 1, "متوسط": 2, "عالي": 3}
+        
+        # حساب درجة المخاطرة
+        p_value = probability_values.get(probability, 1)
+        i_value = impact_values.get(impact, 1)
+        
+        return p_value * i_value
+    
+    def _categorize_risks(self):
+        """تصنيف المخاطر"""
+        categories = {}
+        
+        for risk in self.analysis_results["identified_risks"]:
+            category = risk["category"]
+            if category not in categories:
+                categories[category] = []
+            
+            categories[category].append(risk)
+        
+        # حساب إحصائيات لكل فئة
+        for category, risks in categories.items():
+            total_score = sum(risk["risk_score"] for risk in risks)
+            avg_score = total_score / len(risks) if risks else 0
+            max_score = max(risk["risk_score"] for risk in risks) if risks else 0
+            
+            categories[category] = {
+                "risks": risks,
+                "count": len(risks),
+                "total_score": total_score,
+                "avg_score": avg_score,
+                "max_score": max_score
+            }
+        
+        self.analysis_results["risk_categories"] = categories
+    
+    def _create_risk_matrix(self):
+        """إنشاء مصفوفة المخاطر"""
+        matrix = {
+            "high_impact": {"high_prob": [], "medium_prob": [], "low_prob": []},
+            "medium_impact": {"high_prob": [], "medium_prob": [], "low_prob": []},
+            "low_impact": {"high_prob": [], "medium_prob": [], "low_prob": []}
+        }
+        
+        for risk in self.analysis_results["identified_risks"]:
+            impact = risk["impact"].lower()
+            probability = risk["probability"].lower()
+            
+            impact_key = f"{impact}_impact"
+            if impact == "عالي":
+                impact_key = "high_impact"
+            elif impact == "متوسط":
+                impact_key = "medium_impact"
+            else:
+                impact_key = "low_impact"
+            
+            prob_key = f"{probability}_prob"
+            if probability == "عالي":
+                prob_key = "high_prob"
+            elif probability == "متوسط":
+                prob_key = "medium_prob"
+            else:
+                prob_key = "low_prob"
+            
+            if impact_key in matrix and prob_key in matrix[impact_key]:
+                matrix[impact_key][prob_key].append(risk)
+        
+        self.analysis_results["risk_matrix"] = matrix
+    
+    def _develop_mitigation_strategies(self, method):
+        """تطوير استراتيجيات التخفيف"""
+        strategies = []
+        
+        # استراتيجيات للمخاطر ذات الأولوية العالية
+        high_priority_risks = []
+        
+        # المخاطر ذات التأثير العالي واحتمالية عالية
+        high_priority_risks.extend(self.analysis_results["risk_matrix"]["high_impact"]["high_prob"])
+        
+        # المخاطر ذات التأثير العالي واحتمالية متوسطة
+        high_priority_risks.extend(self.analysis_results["risk_matrix"]["high_impact"]["medium_prob"])
+        
+        # المخاطر ذات التأثير المتوسط واحتمالية عالية
+        high_priority_risks.extend(self.analysis_results["risk_matrix"]["medium_impact"]["high_prob"])
+        
+        for risk in high_priority_risks:
+            strategy = self._generate_mitigation_strategy(risk)
+            strategies.append(strategy)
+        
+        # إذا كانت طريقة التحليل شاملة، أضف استراتيجيات للمخاطر ذات الأولوية المتوسطة
+        if method == "comprehensive":
+            medium_priority_risks = []
+            
+            # المخاطر ذات التأثير العالي واحتمالية منخفضة
+            medium_priority_risks.extend(self.analysis_results["risk_matrix"]["high_impact"]["low_prob"])
+            
+            # المخاطر ذات التأثير المتوسط واحتمالية متوسطة
+            medium_priority_risks.extend(self.analysis_results["risk_matrix"]["medium_impact"]["medium_prob"])
+            
+            # المخاطر ذات التأثير المنخفض واحتمالية عالية
+            medium_priority_risks.extend(self.analysis_results["risk_matrix"]["low_impact"]["high_prob"])
+            
+            for risk in medium_priority_risks:
+                strategy = self._generate_mitigation_strategy(risk)
+                strategies.append(strategy)
+        
+        self.analysis_results["mitigation_strategies"] = strategies
+    
+    def _generate_mitigation_strategy(self, risk):
+        """توليد استراتيجية تخفيف للمخاطر"""
+        strategy_templates = {
+            "توريد": [
+                "إنشاء قائمة بموردين بديلين",
+                "التعاقد المسبق مع الموردين",
+                "تخزين المواد الحرجة مسبقًا",
+                "وضع خطة للتوريد المرحلي"
+            ],
+            "مالي": [
+                "تضمين بند تعديل الأسعار في العقود",
+                "تخصيص ميزانية احتياطية",
+                "التأمين ضد المخاطر المالية",
+                "تحديث دراسة الجدوى بانتظام"
+            ],
+            "بيئي": [
+                "وضع خطة للطوارئ البيئية",
+                "جدولة الأنشطة الحرجة في المواسم المناسبة",
+                "توفير معدات حماية إضافية",
+                "تطبيق تقنيات مقاومة للظروف البيئية"
+            ],
+            "موارد بشرية": [
+                "التعاقد مع شركات توظيف إضافية",
+                "تدريب فرق العمل على مهام متعددة",
+                "وضع خطة للحوافز والمكافآت",
+                "تطوير برنامج للاحتفاظ بالموظفين"
+            ],
+            "فني": [
+                "إجراء اختبارات إضافية قبل التنفيذ",
+                "الاستعانة بخبراء متخصصين",
+                "تطبيق منهجية مراجعة التصميم",
+                "إعداد خطط بديلة للحلول التقنية"
+            ],
+            "إداري": [
+                "تطبيق إجراءات إدارة التغيير",
+                "عقد اجتماعات دورية مع أصحاب المصلحة",
+                "توثيق متطلبات المشروع بشكل تفصيلي",
+                "تحديد نطاق العمل بوضوح في العقود"
+            ],
+            "تنظيمي": [
+                "التواصل المبكر مع الجهات التنظيمية",
+                "تعيين مستشار قانوني متخصص",
+                "متابعة التحديثات التنظيمية بانتظام",
+                "تخصيص وقت إضافي للحصول على الموافقات"
+            ],
+            "خارجي": [
+                "متابعة التطورات السياسية والاقتصادية",
+                "وضع خطط بديلة للسيناريوهات المختلفة",
+                "التأمين ضد المخاطر الخارجية",
+                "تنويع مصادر التوريد والتمويل"
+            ]
+        }
+        
+        # اختيار استراتيجيات مناسبة بناءً على فئة المخاطر
+        category = risk["category"]
+        templates = strategy_templates.get(category, strategy_templates["إداري"])
+        
+        # اختيار استراتيجية عشوائية من القائمة
+        import random
+        strategy_text = random.choice(templates)
+        
+        return {
+            "risk_id": risk["id"],
+            "risk_name": risk["name"],
+            "strategy": strategy_text,
+            "priority": "عالية" if risk["risk_score"] >= 6 else "متوسطة" if risk["risk_score"] >= 3 else "منخفضة",
+            "responsible": "مدير المشروع",
+            "timeline": "قبل بدء المشروع"
+        }
+    
+    def _create_analysis_summary(self, method):
+        """إنشاء ملخص التحليل"""
+        total_risks = len(self.analysis_results["identified_risks"])
+        high_risks = len([r for r in self.analysis_results["identified_risks"] if r["risk_score"] >= 6])
+        medium_risks = len([r for r in self.analysis_results["identified_risks"] if 3 <= r["risk_score"] < 6])
+        low_risks = len([r for r in self.analysis_results["identified_risks"] if r["risk_score"] < 3])
+        
+        # حساب توزيع المخاطر حسب الفئة
+        category_distribution = {}
+        for risk in self.analysis_results["identified_risks"]:
+            category = risk["category"]
+            if category not in category_distribution:
+                category_distribution[category] = 0
+            category_distribution[category] += 1
+        
+        # حساب متوسط درجة المخاطرة
+        avg_risk_score = sum(risk["risk_score"] for risk in self.analysis_results["identified_risks"]) / total_risks if total_risks > 0 else 0
+        
+        # إنشاء الملخص
+        summary = {
+            "total_risks": total_risks,
+            "high_risks": high_risks,
+            "medium_risks": medium_risks,
+            "low_risks": low_risks,
+            "category_distribution": category_distribution,
+            "avg_risk_score": avg_risk_score,
+            "analysis_method": method,
+            "recommendations": self._generate_recommendations(high_risks, medium_risks, low_risks, category_distribution)
+        }
+        
+        self.analysis_results["summary"] = summary
+    
+    def _generate_recommendations(self, high_risks, medium_risks, low_risks, category_distribution):
+        """توليد توصيات بناءً على نتائج التحليل"""
+        recommendations = []
+        
+        # توصيات بناءً على عدد المخاطر العالية
+        if high_risks > 3:
+            recommendations.append("يجب إجراء مراجعة شاملة لخطة المشروع نظرًا لوجود عدد كبير من المخاطر عالية الخطورة.")
+        
+        if high_risks > 0:
+            recommendations.append("تطوير خطط استجابة تفصيلية لجميع المخاطر عالية الخطورة.")
+        
+        # توصيات بناءً على توزيع المخاطر حسب الفئة
+        max_category = max(category_distribution.items(), key=lambda x: x[1], default=(None, 0))
+        if max_category[0]:
+            recommendations.append(f"التركيز على إدارة مخاطر فئة '{max_category[0]}' حيث تمثل النسبة الأكبر من المخاطر المحددة.")
+        
+        # توصيات عامة
+        recommendations.append("إجراء مراجعات دورية لسجل المخاطر وتحديثه بانتظام.")
+        recommendations.append("تعيين مسؤولين محددين لمتابعة استراتيجيات التخفيف من المخاطر.")
+        
+        return recommendations
+    
+    def get_analysis_results(self):
+        """الحصول على نتائج التحليل"""
+        return self.analysis_results
+    
+    def export_analysis_results(self, format="json"):
+        """تصدير نتائج التحليل"""
+        if not self.analysis_results:
+            logger.warning("لا توجد نتائج تحليل للتصدير")
+            return None
+        
+        timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+        project_id = self.analysis_results.get("project_id", "unknown")
+        
+        if format == "json":
+            filename = f"risk_analysis_{project_id}_{timestamp}.json"
+            filepath = self.exports_path / filename
+            
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(self.analysis_results, f, ensure_ascii=False, indent=4)
+            
+            logger.info(f"تم تصدير نتائج التحليل إلى: {filepath}")
+            return filepath
+        
+        else:
+            logger.error(f"تنسيق التصدير غير مدعوم: {format}")
+            return None
+
+
+class RiskAnalysisApp:
+    """تطبيق تحليل المخاطر"""
+    
+    def __init__(self):
+        """تهيئة تطبيق تحليل المخاطر"""
+        self.ui = UIEnhancer(page_title="تحليل المخاطر - نظام تحليل المناقصات", page_icon="⚠️")
+        self.ui.apply_theme_colors()
+        self.risk_analyzer = RiskAnalyzer()
+        
+        # تهيئة بيانات المشاريع
+        if 'projects' not in st.session_state:
+            st.session_state.projects = self._generate_sample_projects()
+        
+        # تهيئة نتائج التحليل
+        if 'risk_analysis_results' not in st.session_state:
+            st.session_state.risk_analysis_results = {}
+    
+    def run(self):
+        """تشغيل تطبيق تحليل المخاطر"""
+        # إنشاء قائمة العناصر
+        menu_items = [
+            {"name": "لوحة المعلومات", "icon": "house"},
+            {"name": "المناقصات والعقود", "icon": "file-text"},
+            {"name": "تحليل المستندات", "icon": "file-earmark-text"},
+            {"name": "نظام التسعير", "icon": "calculator"},
+            {"name": "حاسبة تكاليف البناء", "icon": "building"},
+            {"name": "الموارد والتكاليف", "icon": "people"},
+            {"name": "تحليل المخاطر", "icon": "exclamation-triangle"},
+            {"name": "إدارة المشاريع", "icon": "kanban"},
+            {"name": "الخرائط والمواقع", "icon": "geo-alt"},
+            {"name": "الجدول الزمني", "icon": "calendar3"},
+            {"name": "الإشعارات", "icon": "bell"},
+            {"name": "مقارنة المستندات", "icon": "files"},
+            {"name": "الترجمة", "icon": "translate"},
+            {"name": "المساعد الذكي", "icon": "robot"},
+            {"name": "التقارير", "icon": "bar-chart"},
+            {"name": "الإعدادات", "icon": "gear"}
+        ]
+        
+        # إنشاء الشريط الجانبي
+        selected = self.ui.create_sidebar(menu_items)
+        
+        # إنشاء ترويسة الصفحة
+        self.ui.create_header("تحليل المخاطر", "تحديد وتقييم وإدارة مخاطر المشاريع")
+        
+        # عرض واجهة تحليل المخاطر
+        tabs = st.tabs([
+            "لوحة المعلومات",
+            "تحليل المخاطر",
+            "سجل المخاطر",
+            "مصفوفة المخاطر",
+            "استراتيجيات التخفيف"
+        ])
+        
+        with tabs[0]:
+            self._render_dashboard_tab()
+        
+        with tabs[1]:
+            self._render_analysis_tab()
+        
+        with tabs[2]:
+            self._render_risk_register_tab()
+        
+        with tabs[3]:
+            self._render_risk_matrix_tab()
+        
+        with tabs[4]:
+            self._render_mitigation_strategies_tab()
+    
+    def _render_dashboard_tab(self):
+        """عرض تبويب لوحة المعلومات"""
+        
+        st.markdown("### لوحة معلومات تحليل المخاطر")
+        
+        # عرض إحصائيات المخاطر
+        col1, col2, col3, col4 = st.columns(4)
+        
+        # الحصول على إحصائيات المخاطر
+        total_risks = 0
+        high_risks = 0
+        medium_risks = 0
+        low_risks = 0
+        
+        for project_id, results in st.session_state.risk_analysis_results.items():
+            if "identified_risks" in results:
+                project_risks = results["identified_risks"]
+                total_risks += len(project_risks)
+                high_risks += len([r for r in project_risks if r["risk_score"] >= 6])
+                medium_risks += len([r for r in project_risks if 3 <= r["risk_score"] < 6])
+                low_risks += len([r for r in project_risks if r["risk_score"] < 3])
+        
+        with col1:
+            self.ui.create_metric_card("إجمالي المخاطر", str(total_risks), None, self.ui.COLORS['primary'])
+        
+        with col2:
+            self.ui.create_metric_card("مخاطر عالية", str(high_risks), None, self.ui.COLORS['danger'])
+        
+        with col3:
+            self.ui.create_metric_card("مخاطر متوسطة", str(medium_risks), None, self.ui.COLORS['warning'])
+        
+        with col4:
+            self.ui.create_metric_card("مخاطر منخفضة", str(low_risks), None, self.ui.COLORS['success'])
+        
+        # عرض توزيع المخاطر حسب الفئة
+        st.markdown("#### توزيع المخاطر حسب الفئة")
+        
+        # جمع بيانات توزيع المخاطر
+        category_distribution = {}
+        
+        for project_id, results in st.session_state.risk_analysis_results.items():
+            if "identified_risks" in results:
+                for risk in results["identified_risks"]:
+                    category = risk["category"]
+                    if category not in category_distribution:
+                        category_distribution[category] = 0
+                    category_distribution[category] += 1
+        
+        if category_distribution:
+            # تحويل البيانات إلى DataFrame
+            category_df = pd.DataFrame({
+                'الفئة': list(category_distribution.keys()),
+                'عدد المخاطر': list(category_distribution.values())
+            })
+            
+            # عرض الرسم البياني
+            st.bar_chart(category_df.set_index('الفئة'))
+        else:
+            st.info("لا توجد بيانات كافية لعرض توزيع المخاطر.")
+        
+        # عرض المشاريع ذات المخاطر العالية
+        st.markdown("#### المشاريع ذات المخاطر العالية")
+        
+        high_risk_projects = []
+        
+        for project_id, results in st.session_state.risk_analysis_results.items():
+            if "identified_risks" in results:
+                project_high_risks = len([r for r in results["identified_risks"] if r["risk_score"] >= 6])
+                if project_high_risks > 0:
+                    # البحث عن بيانات المشروع
+                    project = next((p for p in st.session_state.projects if p["id"] == int(project_id)), None)
+                    if project:
+                        high_risk_projects.append({
+                            'اسم المشروع': project["name"],
+                            'رقم المناقصة': project["number"],
+                            'الجهة المالكة': project["client"],
+                            'عدد المخاطر العالية': project_high_risks
+                        })
+        
+        if high_risk_projects:
+            high_risk_df = pd.DataFrame(high_risk_projects)
+            st.dataframe(high_risk_df, use_container_width=True, hide_index=True)
+        else:
+            st.info("لا توجد مشاريع ذات مخاطر عالية حاليًا.")
+    
+    def _render_analysis_tab(self):
+        """عرض تبويب تحليل المخاطر"""
+        
+        st.markdown("### تحليل مخاطر المشروع")
+        
+        # اختيار المشروع
+        project_options = [f"{p['name']} ({p['number']})" for p in st.session_state.projects]
+        selected_project = st.selectbox("اختر المشروع", project_options)
+        
+        if selected_project:
+            # استخراج معرف المشروع من الاختيار
+            project_index = project_options.index(selected_project)
+            project = st.session_state.projects[project_index]
+            project_id = project["id"]
+            
+            # عرض معلومات المشروع
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.markdown(f"**اسم المشروع**: {project['name']}")
+                st.markdown(f"**رقم المناقصة**: {project['number']}")
+                st.markdown(f"**الجهة المالكة**: {project['client']}")
+            
+            with col2:
+                st.markdown(f"**الموقع**: {project['location']}")
+                st.markdown(f"**نوع المشروع**: {project['project_type']}")
+                st.markdown(f"**مستوى التعقيد**: {project['complexity']}")
+            
+            # اختيار طريقة التحليل
+            analysis_method = st.radio(
+                "طريقة التحليل",
+                ["أساسي", "شامل"],
+                format_func=lambda x: "تحليل أساسي" if x == "أساسي" else "تحليل شامل"
+            )
+            
+            # زر بدء التحليل
+            if st.button("بدء تحليل المخاطر"):
+                with st.spinner("جاري تحليل مخاطر المشروع..."):
+                    # محاكاة وقت المعالجة
+                    import time
+                    time.sleep(2)
+                    
+                    # إجراء تحليل المخاطر
+                    self.risk_analyzer.analyze_risks(project_id, method="comprehensive" if analysis_method == "شامل" else "basic")
+                    
+                    # الحصول على نتائج التحليل
+                    results = self.risk_analyzer.get_analysis_results()
+                    
+                    # تخزين النتائج في حالة الجلسة
+                    st.session_state.risk_analysis_results[str(project_id)] = results
+                    
+                    st.success("تم الانتهاء من تحليل المخاطر بنجاح!")
+                    st.experimental_rerun()
+            
+            # عرض نتائج التحليل إذا كانت متوفرة
+            if str(project_id) in st.session_state.risk_analysis_results:
+                results = st.session_state.risk_analysis_results[str(project_id)]
+                
+                st.markdown("#### ملخص نتائج التحليل")
+                
+                if "summary" in results:
+                    summary = results["summary"]
+                    
+                    col1, col2, col3 = st.columns(3)
+                    
+                    with col1:
+                        self.ui.create_metric_card("إجمالي المخاطر", str(summary["total_risks"]), None, self.ui.COLORS['primary'])
+                    
+                    with col2:
+                        self.ui.create_metric_card("مخاطر عالية", str(summary["high_risks"]), None, self.ui.COLORS['danger'])
+                    
+                    with col3:
+                        self.ui.create_metric_card("مخاطر متوسطة", str(summary["medium_risks"]), None, self.ui.COLORS['warning'])
+                    
+                    # عرض توزيع المخاطر حسب الفئة
+                    st.markdown("#### توزيع المخاطر حسب الفئة")
+                    
+                    if "category_distribution" in summary:
+                        category_df = pd.DataFrame({
+                            'الفئة': list(summary["category_distribution"].keys()),
+                            'عدد المخاطر': list(summary["category_distribution"].values())
+                        })
+                        
+                        st.bar_chart(category_df.set_index('الفئة'))
+                    
+                    # عرض التوصيات
+                    st.markdown("#### التوصيات")
+                    
+                    if "recommendations" in summary:
+                        for i, recommendation in enumerate(summary["recommendations"]):
+                            st.markdown(f"{i+1}. {recommendation}")
+                    
+                    # زر تصدير النتائج
+                    if st.button("تصدير نتائج التحليل"):
+                        with st.spinner("جاري تصدير النتائج..."):
+                            # محاكاة وقت المعالجة
+                            time.sleep(1)
+                            
+                            # تصدير النتائج
+                            export_path = self.risk_analyzer.export_analysis_results()
+                            
+                            if export_path:
+                                st.success(f"تم تصدير نتائج التحليل بنجاح!")
+                            else:
+                                st.error("حدث خطأ أثناء تصدير النتائج.")
+    
+    def _render_risk_register_tab(self):
+        """عرض تبويب سجل المخاطر"""
+        
+        st.markdown("### سجل المخاطر")
+        
+        # اختيار المشروع
+        project_options = [f"{p['name']} ({p['number']})" for p in st.session_state.projects]
+        project_options.insert(0, "جميع المشاريع")
+        selected_project_option = st.selectbox("اختر المشروع", project_options, key="risk_register_project")
+        
+        # جمع المخاطر المحددة
+        all_risks = []
+        
+        if selected_project_option == "جميع المشاريع":
+            # جمع المخاطر من جميع المشاريع
+            for project_id, results in st.session_state.risk_analysis_results.items():
+                if "identified_risks" in results:
+                    project = next((p for p in st.session_state.projects if p["id"] == int(project_id)), None)
+                    project_name = project["name"] if project else f"مشروع {project_id}"
+                    
+                    for risk in results["identified_risks"]:
+                        risk_copy = risk.copy()
+                        risk_copy["project_name"] = project_name
+                        all_risks.append(risk_copy)
+        else:
+            # استخراج معرف المشروع من الاختيار
+            project_index = project_options.index(selected_project_option) - 1  # -1 لأننا أضفنا "جميع المشاريع" في البداية
+            project = st.session_state.projects[project_index]
+            project_id = project["id"]
+            
+            # جمع المخاطر من المشروع المحدد
+            if str(project_id) in st.session_state.risk_analysis_results:
+                results = st.session_state.risk_analysis_results[str(project_id)]
+                if "identified_risks" in results:
+                    for risk in results["identified_risks"]:
+                        risk_copy = risk.copy()
+                        risk_copy["project_name"] = project["name"]
+                        all_risks.append(risk_copy)
+        
+        # فلترة المخاطر
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            category_filter = st.multiselect(
+                "فئة المخاطر",
+                list(set(risk["category"] for risk in all_risks)) if all_risks else [],
+                key="risk_register_category"
+            )
+        
+        with col2:
+            probability_filter = st.multiselect(
+                "الاحتمالية",
+                ["عالي", "متوسط", "منخفض"],
+                key="risk_register_probability"
+            )
+        
+        with col3:
+            impact_filter = st.multiselect(
+                "التأثير",
+                ["عالي", "متوسط", "منخفض"],
+                key="risk_register_impact"
+            )
+        
+        # تطبيق الفلترة
+        filtered_risks = all_risks
+        
+        if category_filter:
+            filtered_risks = [risk for risk in filtered_risks if risk["category"] in category_filter]
+        
+        if probability_filter:
+            filtered_risks = [risk for risk in filtered_risks if risk["probability"] in probability_filter]
+        
+        if impact_filter:
+            filtered_risks = [risk for risk in filtered_risks if risk["impact"] in impact_filter]
+        
+        # عرض سجل المخاطر
+        if filtered_risks:
+            # تحويل المخاطر إلى DataFrame
+            risk_data = []
+            for risk in filtered_risks:
+                risk_data.append({
+                    'المشروع': risk.get("project_name", ""),
+                    'اسم المخاطرة': risk["name"],
+                    'الوصف': risk.get("description", ""),
+                    'الفئة': risk["category"],
+                    'الاحتمالية': risk["probability"],
+                    'التأثير': risk["impact"],
+                    'درجة المخاطرة': risk["risk_score"]
+                })
+            
+            risk_df = pd.DataFrame(risk_data)
+            
+            # ترتيب المخاطر حسب درجة المخاطرة (تنازليًا)
+            risk_df = risk_df.sort_values(by='درجة المخاطرة', ascending=False)
+            
+            # عرض الجدول
+            st.dataframe(risk_df, use_container_width=True, hide_index=True)
+            
+            # زر تصدير سجل المخاطر
+            if st.button("تصدير سجل المخاطر"):
+                with st.spinner("جاري تصدير سجل المخاطر..."):
+                    # محاكاة وقت المعالجة
+                    time.sleep(1)
+                    st.success("تم تصدير سجل المخاطر بنجاح!")
+        else:
+            st.info("لا توجد مخاطر تطابق معايير البحث أو لم يتم إجراء تحليل للمخاطر بعد.")
+    
+    def _render_risk_matrix_tab(self):
+        """عرض تبويب مصفوفة المخاطر"""
+        
+        st.markdown("### مصفوفة المخاطر")
+        
+        # اختيار المشروع
+        project_options = [f"{p['name']} ({p['number']})" for p in st.session_state.projects]
+        selected_project = st.selectbox("اختر المشروع", project_options, key="risk_matrix_project")
+        
+        if selected_project:
+            # استخراج معرف المشروع من الاختيار
+            project_index = project_options.index(selected_project)
+            project = st.session_state.projects[project_index]
+            project_id = project["id"]
+            
+            # التحقق من وجود نتائج تحليل للمشروع
+            if str(project_id) in st.session_state.risk_analysis_results:
+                results = st.session_state.risk_analysis_results[str(project_id)]
+                
+                if "risk_matrix" in results:
+                    matrix = results["risk_matrix"]
+                    
+                    # إنشاء مصفوفة المخاطر
+                    st.markdown("#### مصفوفة احتمالية وتأثير المخاطر")
+                    
+                    # إنشاء بيانات المصفوفة
+                    matrix_data = [
+                        [len(matrix["high_impact"]["high_prob"]), len(matrix["high_impact"]["medium_prob"]), len(matrix["high_impact"]["low_prob"])],
+                        [len(matrix["medium_impact"]["high_prob"]), len(matrix["medium_impact"]["medium_prob"]), len(matrix["medium_impact"]["low_prob"])],
+                        [len(matrix["low_impact"]["high_prob"]), len(matrix["low_impact"]["medium_prob"]), len(matrix["low_impact"]["low_prob"])]
+                    ]
+                    
+                    # تحويل البيانات إلى DataFrame
+                    matrix_df = pd.DataFrame(
+                        matrix_data,
+                        columns=["احتمالية عالية", "احتمالية متوسطة", "احتمالية منخفضة"],
+                        index=["تأثير عالي", "تأثير متوسط", "تأثير منخفض"]
+                    )
+                    
+                    # عرض المصفوفة كجدول
+                    st.dataframe(matrix_df)
+                    
+                    # عرض تفاصيل المخاطر في كل خلية
+                    st.markdown("#### تفاصيل المخاطر في المصفوفة")
+                    
+                    # إنشاء تبويبات للخلايا المختلفة
+                    matrix_tabs = st.tabs([
+                        "تأثير عالي / احتمالية عالية",
+                        "تأثير عالي / احتمالية متوسطة",
+                        "تأثير متوسط / احتمالية عالية",
+                        "تأثير متوسط / احتمالية متوسطة",
+                        "أخرى"
+                    ])
+                    
+                    # عرض المخاطر في كل تبويب
+                    with matrix_tabs[0]:
+                        self._display_cell_risks(matrix["high_impact"]["high_prob"], "تأثير عالي / احتمالية عالية")
+                    
+                    with matrix_tabs[1]:
+                        self._display_cell_risks(matrix["high_impact"]["medium_prob"], "تأثير عالي / احتمالية متوسطة")
+                    
+                    with matrix_tabs[2]:
+                        self._display_cell_risks(matrix["medium_impact"]["high_prob"], "تأثير متوسط / احتمالية عالية")
+                    
+                    with matrix_tabs[3]:
+                        self._display_cell_risks(matrix["medium_impact"]["medium_prob"], "تأثير متوسط / احتمالية متوسطة")
+                    
+                    with matrix_tabs[4]:
+                        # جمع المخاطر الأخرى
+                        other_risks = []
+                        other_risks.extend(matrix["high_impact"]["low_prob"])
+                        other_risks.extend(matrix["medium_impact"]["low_prob"])
+                        other_risks.extend(matrix["low_impact"]["high_prob"])
+                        other_risks.extend(matrix["low_impact"]["medium_prob"])
+                        other_risks.extend(matrix["low_impact"]["low_prob"])
+                        
+                        self._display_cell_risks(other_risks, "مخاطر أخرى")
+                else:
+                    st.warning("لم يتم العثور على مصفوفة المخاطر للمشروع المحدد.")
+            else:
+                st.warning("لم يتم إجراء تحليل للمخاطر لهذا المشروع بعد.")
+    
+    def _display_cell_risks(self, risks, cell_title):
+        """عرض المخاطر في خلية من مصفوفة المخاطر"""
+        
+        if risks:
+            st.markdown(f"##### {cell_title} ({len(risks)} مخاطر)")
+            
+            # تحويل المخاطر إلى DataFrame
+            risk_data = []
+            for risk in risks:
+                risk_data.append({
+                    'اسم المخاطرة': risk["name"],
+                    'الوصف': risk.get("description", ""),
+                    'الفئة': risk["category"],
+                    'درجة المخاطرة': risk["risk_score"]
+                })
+            
+            risk_df = pd.DataFrame(risk_data)
+            
+            # عرض الجدول
+            st.dataframe(risk_df, use_container_width=True, hide_index=True)
+        else:
+            st.info(f"لا توجد مخاطر في خلية {cell_title}.")
+    
+    def _render_mitigation_strategies_tab(self):
+        """عرض تبويب استراتيجيات التخفيف"""
+        
+        st.markdown("### استراتيجيات التخفيف من المخاطر")
+        
+        # اختيار المشروع
+        project_options = [f"{p['name']} ({p['number']})" for p in st.session_state.projects]
+        selected_project = st.selectbox("اختر المشروع", project_options, key="mitigation_project")
+        
+        if selected_project:
+            # استخراج معرف المشروع من الاختيار
+            project_index = project_options.index(selected_project)
+            project = st.session_state.projects[project_index]
+            project_id = project["id"]
+            
+            # التحقق من وجود نتائج تحليل للمشروع
+            if str(project_id) in st.session_state.risk_analysis_results:
+                results = st.session_state.risk_analysis_results[str(project_id)]
+                
+                if "mitigation_strategies" in results and results["mitigation_strategies"]:
+                    strategies = results["mitigation_strategies"]
+                    
+                    # فلترة الاستراتيجيات
+                    priority_filter = st.multiselect(
+                        "الأولوية",
+                        ["عالية", "متوسطة", "منخفضة"],
+                        default=["عالية"],
+                        key="mitigation_priority"
+                    )
+                    
+                    # تطبيق الفلترة
+                    filtered_strategies = strategies
+                    if priority_filter:
+                        filtered_strategies = [s for s in filtered_strategies if s["priority"] in priority_filter]
+                    
+                    # عرض استراتيجيات التخفيف
+                    if filtered_strategies:
+                        # تحويل الاستراتيجيات إلى DataFrame
+                        strategy_data = []
+                        for strategy in filtered_strategies:
+                            strategy_data.append({
+                                'المخاطرة': strategy["risk_name"],
+                                'استراتيجية التخفيف': strategy["strategy"],
+                                'الأولوية': strategy["priority"],
+                                'المسؤول': strategy["responsible"],
+                                'الإطار الزمني': strategy["timeline"]
+                            })
+                        
+                        strategy_df = pd.DataFrame(strategy_data)
+                        
+                        # ترتيب الاستراتيجيات حسب الأولوية
+                        priority_order = {"عالية": 0, "متوسطة": 1, "منخفضة": 2}
+                        strategy_df["priority_order"] = strategy_df["الأولوية"].map(priority_order)
+                        strategy_df = strategy_df.sort_values(by="priority_order")
+                        strategy_df = strategy_df.drop(columns=["priority_order"])
+                        
+                        # عرض الجدول
+                        st.dataframe(strategy_df, use_container_width=True, hide_index=True)
+                        
+                        # زر تصدير استراتيجيات التخفيف
+                        if st.button("تصدير استراتيجيات التخفيف"):
+                            with st.spinner("جاري تصدير استراتيجيات التخفيف..."):
+                                # محاكاة وقت المعالجة
+                                time.sleep(1)
+                                st.success("تم تصدير استراتيجيات التخفيف بنجاح!")
+                    else:
+                        st.info("لا توجد استراتيجيات تخفيف تطابق معايير الفلترة.")
+                else:
+                    st.warning("لم يتم العثور على استراتيجيات تخفيف للمشروع المحدد.")
+            else:
+                st.warning("لم يتم إجراء تحليل للمخاطر لهذا المشروع بعد.")
+    
+    def _generate_sample_projects(self):
+        """توليد بيانات افتراضية للمشاريع"""
+        
+        return [
+            {
+                'id': 1,
+                'name': "إنشاء مبنى مستشفى الولادة والأطفال بمنطقة الشرقية",
+                'number': "SHPD-2025-001",
+                'client': "وزارة الصحة",
+                'location': "الدمام، المنطقة الشرقية",
+                'description': "يشمل المشروع إنشاء وتجهيز مبنى مستشفى الولادة والأطفال بسعة 300 سرير، ويتكون المبنى من 4 طوابق بمساحة إجمالية 15,000 متر مربع.",
+                'status': "قيد التسعير",
+                'tender_type': "عامة",
+                'pricing_method': "قياسي",
+                'submission_date': (datetime.datetime.now() + datetime.timedelta(days=5)),
+                'created_at': datetime.datetime.now() - datetime.timedelta(days=10),
+                'created_by_id': 1,
+                'project_type': "مباني",
+                'complexity': "عالي"
+            },
+            {
+                'id': 2,
+                'name': "صيانة وتطوير طريق الملك عبدالله",
+                'number': "MOT-2025-042",
+                'client': "وزارة النقل",
+                'location': "الرياض، المنطقة الوسطى",
+                'description': "صيانة وتطوير طريق الملك عبدالله بطول 25 كم، ويشمل المشروع إعادة الرصف وتحسين الإنارة وتركيب اللوحات الإرشادية.",
+                'status': "تم التقديم",
+                'tender_type': "عامة",
+                'pricing_method': "غير متزن",
+                'submission_date': (datetime.datetime.now() - datetime.timedelta(days=15)),
+                'created_at': datetime.datetime.now() - datetime.timedelta(days=45),
+                'created_by_id': 1,
+                'project_type': "بنية تحتية",
+                'complexity': "متوسط"
+            },
+            {
+                'id': 3,
+                'name': "إنشاء محطة معالجة مياه الصرف الصحي",
+                'number': "SWPC-2025-007",
+                'client': "شركة المياه الوطنية",
+                'location': "جدة، المنطقة الغربية",
+                'description': "إنشاء محطة معالجة مياه الصرف الصحي بطاقة استيعابية 50,000 م3/يوم، مع جميع الأعمال المدنية والكهروميكانيكية.",
+                'status': "تمت الترسية",
+                'tender_type': "عامة",
+                'pricing_method': "قياسي",
+                'submission_date': (datetime.datetime.now() - datetime.timedelta(days=90)),
+                'created_at': datetime.datetime.now() - datetime.timedelta(days=120),
+                'created_by_id': 1,
+                'project_type': "بنية تحتية",
+                'complexity': "عالي"
+            }
+        ]
+
+# تشغيل التطبيق
+if __name__ == "__main__":
+    risk_app = RiskAnalysisApp()
+    risk_app.run()

modules/translation/translation_app.py

@@ -0,0 +1,936 @@
+"""
+وحدة الترجمة - نظام تحليل المناقصات
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import os
+import sys
+from pathlib import Path
+import re
+import datetime
+
+# إضافة مسار المشروع للنظام
+sys.path.append(str(Path(__file__).parent.parent))
+
+# استيراد محسن واجهة المستخدم
+from styling.enhanced_ui import UIEnhancer
+
+class TranslationApp:
+    """تطبيق الترجمة"""
+    
+    def __init__(self):
+        """تهيئة تطبيق الترجمة"""
+        self.ui = UIEnhancer(page_title="الترجمة - نظام تحليل المناقصات", page_icon="🌐")
+        self.ui.apply_theme_colors()
+        
+        # قائمة اللغات المدعومة
+        self.supported_languages = {
+            "ar": "العربية",
+            "en": "الإنجليزية",
+            "fr": "الفرنسية",
+            "de": "الألمانية",
+            "es": "الإسبانية",
+            "it": "الإيطالية",
+            "zh": "الصينية",
+            "ja": "اليابانية",
+            "ru": "الروسية",
+            "tr": "التركية"
+        }
+        
+        # بيانات نموذجية للمصطلحات الفنية
+        self.technical_terms = [
+            {"ar": "كراسة الشروط", "en": "Terms and Conditions Document", "category": "مستندات"},
+            {"ar": "جدول الكميات", "en": "Bill of Quantities (BOQ)", "category": "مستندات"},
+            {"ar": "المواصفات الفنية", "en": "Technical Specifications", "category": "مستندات"},
+            {"ar": "ضمان ابتدائي", "en": "Bid Bond", "category": "ضمانات"},
+            {"ar": "ضمان حسن التنفيذ", "en": "Performance Bond", "category": "ضمانات"},
+            {"ar": "ضمان دفعة مقدمة", "en": "Advance Payment Guarantee", "category": "ضمانات"},
+            {"ar": "ضمان صيانة", "en": "Maintenance Bond", "category": "ضمانات"},
+            {"ar": "مناقصة عامة", "en": "Public Tender", "category": "أنواع المناقصات"},
+            {"ar": "مناقصة محدودة", "en": "Limited Tender", "category": "أنواع المناقصات"},
+            {"ar": "منافسة", "en": "Competition", "category": "أنواع المناقصات"},
+            {"ar": "أمر شراء", "en": "Purchase Order", "category": "عقود"},
+            {"ar": "عقد إطاري", "en": "Framework Agreement", "category": "عقود"},
+            {"ar": "عقد زمني", "en": "Time-based Contract", "category": "عقود"},
+            {"ar": "عقد تسليم مفتاح", "en": "Turnkey Contract", "category": "عقود"},
+            {"ar": "مقاول من الباطن", "en": "Subcontractor", "category": "أطراف"},
+            {"ar": "استشاري", "en": "Consultant", "category": "أطراف"},
+            {"ar": "مالك المشروع", "en": "Project Owner", "category": "أطراف"},
+            {"ar": "مدير المشروع", "en": "Project Manager", "category": "أطراف"},
+            {"ar": "مهندس الموقع", "en": "Site Engineer", "category": "أطراف"},
+            {"ar": "مراقب الجودة", "en": "Quality Control", "category": "أطراف"},
+            {"ar": "أعمال مدنية", "en": "Civil Works", "category": "أعمال"},
+            {"ar": "أعمال كهربائية", "en": "Electrical Works", "category": "أعمال"},
+            {"ar": "أعمال ميكانيكية", "en": "Mechanical Works", "category": "أعمال"},
+            {"ar": "أعمال معمارية", "en": "Architectural Works", "category": "أعمال"},
+            {"ar": "أعمال تشطيبات", "en": "Finishing Works", "category": "أعمال"},
+            {"ar": "غرامة تأخير", "en": "Delay Penalty", "category": "شروط"},
+            {"ar": "مدة التنفيذ", "en": "Execution Period", "category": "شروط"},
+            {"ar": "فترة الضمان", "en": "Warranty Period", "category": "شروط"},
+            {"ar": "شروط الدفع", "en": "Payment Terms", "category": "شروط"},
+            {"ar": "تسوية النزاعات", "en": "Dispute Resolution", "category": "شروط"}
+        ]
+        
+        # بيانات نموذجية للمستندات المترجمة
+        self.translated_documents = [
+            {
+                "id": "TD001",
+                "name": "كراسة الشروط - مناقصة إنشاء مبنى إداري",
+                "source_language": "ar",
+                "target_language": "en",
+                "original_file": "specs_v2.0_ar.pdf",
+                "translated_file": "specs_v2.0_en.pdf",
+                "translation_date": "2025-03-15",
+                "translated_by": "أحمد محمد",
+                "status": "مكتمل",
+                "pages": 52,
+                "related_entity": "T-2025-001"
+            },
+            {
+                "id": "TD002",
+                "name": "جدول الكميات - مناقصة إنشاء مبنى إداري",
+                "source_language": "ar",
+                "target_language": "en",
+                "original_file": "boq_v1.1_ar.xlsx",
+                "translated_file": "boq_v1.1_en.xlsx",
+                "translation_date": "2025-02-25",
+                "translated_by": "سارة عبدالله",
+                "status": "مكتمل",
+                "pages": 22,
+                "related_entity": "T-2025-001"
+            },
+            {
+                "id": "TD003",
+                "name": "المخططات - مناقصة إنشاء مبنى إداري",
+                "source_language": "ar",
+                "target_language": "en",
+                "original_file": "drawings_v2.0_ar.pdf",
+                "translated_file": "drawings_v2.0_en.pdf",
+                "translation_date": "2025-03-20",
+                "translated_by": "محمد علي",
+                "status": "مكتمل",
+                "pages": 35,
+                "related_entity": "T-2025-001"
+            },
+            {
+                "id": "TD004",
+                "name": "كراسة الشروط - مناقصة صيانة طرق",
+                "source_language": "ar",
+                "target_language": "en",
+                "original_file": "specs_v1.1_ar.pdf",
+                "translated_file": "specs_v1.1_en.pdf",
+                "translation_date": "2025-03-25",
+                "translated_by": "فاطمة أحمد",
+                "status": "مكتمل",
+                "pages": 34,
+                "related_entity": "T-2025-002"
+            },
+            {
+                "id": "TD005",
+                "name": "جدول الكميات - مناقصة صيانة طرق",
+                "source_language": "ar",
+                "target_language": "en",
+                "original_file": "boq_v1.0_ar.xlsx",
+                "translated_file": "boq_v1.0_en.xlsx",
+                "translation_date": "2025-03-10",
+                "translated_by": "خالد عمر",
+                "status": "مكتمل",
+                "pages": 15,
+                "related_entity": "T-2025-002"
+            },
+            {
+                "id": "TD006",
+                "name": "كراسة الشروط - مناقصة توريد معدات",
+                "source_language": "en",
+                "target_language": "ar",
+                "original_file": "specs_v1.0_en.pdf",
+                "translated_file": "specs_v1.0_ar.pdf",
+                "translation_date": "2025-02-15",
+                "translated_by": "أحمد محمد",
+                "status": "مكتمل",
+                "pages": 28,
+                "related_entity": "T-2025-003"
+            },
+            {
+                "id": "TD007",
+                "name": "عقد توريد - مناقصة توريد معدات",
+                "source_language": "en",
+                "target_language": "ar",
+                "original_file": "contract_v1.0_en.pdf",
+                "translated_file": "contract_v1.0_ar.pdf",
+                "translation_date": "2025-03-05",
+                "translated_by": "سارة عبدالله",
+                "status": "مكتمل",
+                "pages": 20,
+                "related_entity": "T-2025-003"
+            },
+            {
+                "id": "TD008",
+                "name": "كراسة الشروط - مناقصة تجهيز مختبرات",
+                "source_language": "ar",
+                "target_language": "en",
+                "original_file": "specs_v1.0_ar.pdf",
+                "translated_file": "specs_v1.0_en.pdf",
+                "translation_date": "2025-03-28",
+                "translated_by": "محمد علي",
+                "status": "قيد التنفيذ",
+                "pages": 30,
+                "related_entity": "T-2025-004"
+            }
+        ]
+        
+        # بيانات نموذجية للنصوص المترجمة
+        self.sample_translations = {
+            "text1": {
+                "ar": """
+                # كراسة الشروط والمواصفات
+                ## مناقصة إنشاء مبنى إداري
+                
+                ### 1. مقدمة
+                تدعو شركة شبه الجزيرة للمقاولات الشركات المتخصصة للتقدم بعروضها لتنفيذ مشروع إنشاء مبنى إداري في مدينة الرياض.
+                
+                ### 2. نطاق العمل
+                يشمل نطاق العمل تصميم وتنفيذ مبنى إداري مكون من 6 طوابق بمساحة إجمالية 6000 متر مربع، ويشمل ذلك:
+                - أعمال الهيكل الإنشائي
+                - أعمال التشطيبات الداخلية والخارجية
+                - أعمال الكهرباء والميكانيكا
+                - أعمال تنسيق الموقع
+                - أعمال أنظمة الأمن والسلامة
+                - أعمال أنظمة المباني الذكية
+                """,
+                
+                "en": """
+                # Terms and Conditions Document
+                ## Administrative Building Construction Tender
+                
+                ### 1. Introduction
+                Peninsula Contracting Company invites specialized companies to submit their offers for the implementation of an administrative building construction project in Riyadh.
+                
+                ### 2. Scope of Work
+                The scope of work includes the design and implementation of a 6-floor administrative building with a total area of 6000 square meters, including:
+                - Structural works
+                - Interior and exterior finishing works
+                - Electrical and mechanical works
+                - Site coordination works
+                - Security and safety systems works
+                - Smart building systems works
+                """
+            },
+            
+            "text2": {
+                "ar": """
+                ### 3. المواصفات الفنية
+                #### 3.1 أعمال الخرسانة
+                - يجب أن تكون الخرسانة المسلحة بقوة لا تقل عن 40 نيوتن/مم²
+                - يجب استخدام حديد تسليح مطابق للمواصفات السعودية
+                - يجب استخدام إضافات للخرسانة لزيادة مقاومتها للعوامل الجوية
+                
+                #### 3.2 أعمال التشطيبات
+                - يجب استخدام مواد عالية الجودة للتشطيبات الداخلية
+                - يجب أن تكون الواجهات الخارجية مقاومة للعوامل الجوية
+                - يجب استخدام زجاج عاكس للحرارة للواجهات
+                - يجب استخدام مواد صديقة للبيئة
+                """,
+                
+                "en": """
+                ### 3. Technical Specifications
+                #### 3.1 Concrete Works
+                - Reinforced concrete must have a strength of not less than 40 Newton/mm²
+                - Reinforcement steel must comply with Saudi specifications
+                - Concrete additives must be used to increase its resistance to weather conditions
+                
+                #### 3.2 Finishing Works
+                - High-quality materials must be used for interior finishes
+                - Exterior facades must be weather-resistant
+                - Heat-reflective glass must be used for facades
+                - Environmentally friendly materials must be used
+                """
+            }
+        }
+    
+    def run(self):
+        """تشغيل تطبيق الترجمة"""
+        # إنشاء قائمة العناصر
+        menu_items = [
+            {"name": "لوحة المعلومات", "icon": "house"},
+            {"name": "المناقصات والعقود", "icon": "file-text"},
+            {"name": "تحليل المستندات", "icon": "file-earmark-text"},
+            {"name": "نظام التسعير", "icon": "calculator"},
+            {"name": "حاسبة تكاليف البناء", "icon": "building"},
+            {"name": "الموارد والتكاليف", "icon": "people"},
+            {"name": "تحليل المخاطر", "icon": "exclamation-triangle"},
+            {"name": "إدارة المشاريع", "icon": "kanban"},
+            {"name": "الخرائط والمواقع", "icon": "geo-alt"},
+            {"name": "الجدول الزمني", "icon": "calendar3"},
+            {"name": "الإشعارات", "icon": "bell"},
+            {"name": "مقارنة المستندات", "icon": "files"},
+            {"name": "الترجمة", "icon": "translate"},
+            {"name": "المساعد الذكي", "icon": "robot"},
+            {"name": "التقارير", "icon": "bar-chart"},
+            {"name": "الإعدادات", "icon": "gear"}
+        ]
+        
+        # إنشاء الشريط الجانبي
+        selected = self.ui.create_sidebar(menu_items)
+        
+        # إنشاء ترويسة الصفحة
+        self.ui.create_header("الترجمة", "أدوات ترجمة المستندات والنصوص")
+        
+        # إنشاء علامات تبويب للوظائف المختلفة
+        tabs = st.tabs(["ترجمة النصوص", "ترجمة المستندات", "قاموس المصطلحات", "المستندات المترجمة"])
+        
+        # علامة تبويب ترجمة النصوص
+        with tabs[0]:
+            self.translate_text()
+        
+        # علامة تبويب ترجمة المستندات
+        with tabs[1]:
+            self.translate_documents()
+        
+        # علامة تبويب قاموس المصطلحات
+        with tabs[2]:
+            self.technical_terms_dictionary()
+        
+        # علامة تبويب المستندات المترجمة
+        with tabs[3]:
+            self.show_translated_documents()
+    
+    def translate_text(self):
+        """ترجمة النصوص"""
+        st.markdown("### ترجمة النصوص")
+        
+        # اختيار لغات الترجمة
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            source_language = st.selectbox(
+                "لغة المصدر",
+                options=list(self.supported_languages.keys()),
+                format_func=lambda x: self.supported_languages[x],
+                index=0  # العربية كلغة افتراضية
+            )
+        
+        with col2:
+            # استبعاد لغة المصدر من خيارات لغة الهدف
+            target_languages = {k: v for k, v in self.supported_languages.items() if k != source_language}
+            target_language = st.selectbox(
+                "لغة الهدف",
+                options=list(target_languages.keys()),
+                format_func=lambda x: self.supported_languages[x],
+                index=0  # أول لغة متاحة
+            )
+        
+        # خيارات الترجمة
+        st.markdown("#### خيارات الترجمة")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            translation_engine = st.radio(
+                "محرك الترجمة",
+                options=["OpenAI", "Google Translate", "Microsoft Translator", "محلي"]
+            )
+        
+        with col2:
+            use_technical_terms = st.checkbox("استخدام قاموس المصطلحات الفنية", value=True)
+        
+        with col3:
+            preserve_formatting = st.checkbox("الحفاظ على التنسيق", value=True)
+        
+        # إدخال النص المراد ترجمته
+        st.markdown("#### النص المراد ترجمته")
+        
+        # إضافة أمثلة نصية
+        examples = st.expander("أمثلة نصية")
+        with examples:
+            if st.button("مثال 1: مقدمة كراسة الشروط"):
+                source_text = self.sample_translations["text1"][source_language] if source_language in self.sample_translations["text1"] else self.sample_translations["text1"]["ar"]
+            elif st.button("مثال 2: المواصفات الفنية"):
+                source_text = self.sample_translations["text2"][source_language] if source_language in self.sample_translations["text2"] else self.sample_translations["text2"]["ar"]
+            else:
+                source_text = ""
+        
+        if "source_text" not in locals():
+            source_text = ""
+        
+        source_text = st.text_area(
+            "أدخل النص المراد ترجمته",
+            value=source_text,
+            height=200
+        )
+        
+        # زر الترجمة
+        if st.button("ترجمة النص", use_container_width=True):
+            if not source_text:
+                st.error("يرجى إدخال النص المراد ترجمته")
+            else:
+                # في تطبيق حقيقي، سيتم استدعاء واجهة برمجة التطبيقات للترجمة
+                # هنا نستخدم النصوص النموذجية المحددة مسبقاً للعرض
+                
+                with st.spinner("جاري الترجمة..."):
+                    # محاكاة تأخير الترجمة
+                    import time
+                    time.sleep(1)
+                    
+                    # التحقق من وجود ترجمة نموذجية
+                    if source_language == "ar" and target_language == "en" and source_text.strip() in [self.sample_translations["text1"]["ar"].strip(), self.sample_translations["text2"]["ar"].strip()]:
+                        if source_text.strip() == self.sample_translations["text1"]["ar"].strip():
+                            translated_text = self.sample_translations["text1"]["en"]
+                        else:
+                            translated_text = self.sample_translations["text2"]["en"]
+                    elif source_language == "en" and target_language == "ar" and source_text.strip() in [self.sample_translations["text1"]["en"].strip(), self.sample_translations["text2"]["en"].strip()]:
+                        if source_text.strip() == self.sample_translations["text1"]["en"].strip():
+                            translated_text = self.sample_translations["text1"]["ar"]
+                        else:
+                            translated_text = self.sample_translations["text2"]["ar"]
+                    else:
+                        # ترجمة نموذجية للعرض فقط
+                        translated_text = f"[هذا نص مترجم نموذجي من {self.supported_languages[source_language]} إلى {self.supported_languages[target_language]}]\n\n{source_text}"
+                
+                # عرض النص المترجم
+                st.markdown("#### النص المترجم")
+                st.text_area(
+                    "النص المترجم",
+                    value=translated_text,
+                    height=200
+                )
+                
+                # أزرار إضافية
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    if st.button("نسخ النص المترجم", use_container_width=True):
+                        st.success("تم نسخ النص المترجم إلى الحافظة")
+                
+                with col2:
+                    if st.button("حفظ الترجمة", use_container_width=True):
+                        st.success("تم حفظ الترجمة بنجاح")
+                
+                with col3:
+                    if st.button("تصدير كملف", use_container_width=True):
+                        st.success("تم تصدير الترجمة كملف بنجاح")
+                
+                # عرض إحصائيات الترجمة
+                st.markdown("#### إحصائيات الترجمة")
+                
+                col1, col2, col3, col4 = st.columns(4)
+                
+                with col1:
+                    self.ui.create_metric_card(
+                        "عدد الكلمات",
+                        str(len(source_text.split())),
+                        None,
+                        self.ui.COLORS['primary']
+                    )
+                
+                with col2:
+                    self.ui.create_metric_card(
+                        "عدد الأحرف",
+                        str(len(source_text)),
+                        None,
+                        self.ui.COLORS['secondary']
+                    )
+                
+                with col3:
+                    self.ui.create_metric_card(
+                        "وقت الترجمة",
+                        "1.2 ثانية",
+                        None,
+                        self.ui.COLORS['success']
+                    )
+                
+                with col4:
+                    self.ui.create_metric_card(
+                        "المصطلحات الفنية",
+                        "5",
+                        None,
+                        self.ui.COLORS['accent']
+                    )
+    
+    def translate_documents(self):
+        """ترجمة المستندات"""
+        st.markdown("### ترجمة المستندات")
+        
+        # اختيار لغات الترجمة
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            source_language = st.selectbox(
+                "لغة المصدر",
+                options=list(self.supported_languages.keys()),
+                format_func=lambda x: self.supported_languages[x],
+                index=0,  # العربية كلغة افتراضية
+                key="doc_source_lang"
+            )
+        
+        with col2:
+            # استبعاد لغة المصدر من خيارات لغة الهدف
+            target_languages = {k: v for k, v in self.supported_languages.items() if k != source_language}
+            target_language = st.selectbox(
+                "لغة الهدف",
+                options=list(target_languages.keys()),
+                format_func=lambda x: self.supported_languages[x],
+                index=0,  # أول لغة متاحة
+                key="doc_target_lang"
+            )
+        
+        # تحميل المستند
+        st.markdown("#### تحميل المستند")
+        
+        uploaded_file = st.file_uploader("اختر المستند المراد ترجمته", type=["pdf", "docx", "xlsx", "txt"])
+        
+        if uploaded_file is not None:
+            st.success(f"تم تحميل الملف: {uploaded_file.name}")
+            
+            # عرض معلومات الملف
+            file_details = {
+                "اسم الملف": uploaded_file.name,
+                "نوع الملف": uploaded_file.type,
+                "حجم الملف": f"{uploaded_file.size / 1024:.1f} كيلوبايت"
+            }
+            
+            st.json(file_details)
+        
+        # خيارات الترجمة
+        st.markdown("#### خيارات الترجمة")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            translation_engine = st.radio(
+                "محرك الترجمة",
+                options=["OpenAI", "Google Translate", "Microsoft Translator", "محلي"],
+                key="doc_engine"
+            )
+            
+            use_technical_terms = st.checkbox("استخدام قاموس المصطلحات الفنية", value=True, key="doc_terms")
+        
+        with col2:
+            preserve_formatting = st.checkbox("الحفاظ على التنسيق", value=True, key="doc_format")
+            
+            translate_images = st.checkbox("ترجمة النصوص في الصور", value=False)
+            
+            maintain_layout = st.checkbox("الحفاظ على تخطيط المستند", value=True)
+        
+        # معلومات إضافية
+        st.markdown("#### معلومات إضافية")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            document_name = st.text_input("اسم المستند")
+        
+        with col2:
+            related_entity = st.text_input("الكيان المرتبط (مثل: رقم المناقصة أو المشروع)")
+        
+        # زر بدء الترجمة
+        if st.button("بدء ترجمة المستند", use_container_width=True):
+            if uploaded_file is None:
+                st.error("يرجى تحميل المستند المراد ترجمته")
+            else:
+                # في تطبيق حقيقي، سيتم إرسال المستند إلى خدمة الترجمة
+                # هنا نعرض محاكاة لعملية الترجمة
+                
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                # محاكاة تقدم الترجمة
+                import time
+                for i in range(101):
+                    progress_bar.progress(i)
+                    
+                    if i < 10:
+                        status_text.text("جاري تحليل المستند...")
+                    elif i < 30:
+                        status_text.text("جاري استخراج النصوص...")
+                    elif i < 70:
+                        status_text.text("جاري ترجمة المحتوى...")
+                    elif i < 90:
+                        status_text.text("جاري إعادة بناء المستند...")
+                    else:
+                        status_text.text("جاري إنهاء الترجمة...")
+                    
+                    time.sleep(0.05)
+                
+                # عرض نتيجة الترجمة
+                st.success("تمت ترجمة المستند بنجاح!")
+                
+                # إنشاء اسم الملف المترجم
+                file_name_parts = uploaded_file.name.split('.')
+                translated_file_name = f"{'.'.join(file_name_parts[:-1])}_{target_language}.{file_name_parts[-1]}"
+                
+                # عرض معلومات الملف المترجم
+                st.markdown("#### معلومات الملف المترجم")
+                
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.markdown(f"**اسم الملف:** {translated_file_name}")
+                    st.markdown(f"**لغة المصدر:** {self.supported_languages[source_language]}")
+                    st.markdown(f"**لغة الهدف:** {self.supported_languages[target_language]}")
+                
+                with col2:
+                    st.markdown(f"**محرك الترجمة:** {translation_engine}")
+                    st.markdown(f"**تاريخ الترجمة:** {datetime.datetime.now().strftime('%Y-%m-%d')}")
+                    st.markdown(f"**حالة الترجمة:** مكتمل")
+                
+                # أزرار إضافية
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    if st.button("تنزيل الملف المترجم", use_container_width=True):
+                        st.success("تم بدء تنزيل الملف المترجم")
+                
+                with col2:
+                    if st.button("حفظ في المستندات المترجمة", use_container_width=True):
+                        st.success("تم حفظ الملف في المستندات المترجمة")
+                
+                with col3:
+                    if st.button("مشاركة الملف", use_container_width=True):
+                        st.success("تم نسخ رابط مشاركة الملف")
+                
+                # عرض إحصائيات الترجمة
+                st.markdown("#### إحصائيات الترجمة")
+                
+                col1, col2, col3, col4 = st.columns(4)
+                
+                with col1:
+                    self.ui.create_metric_card(
+                        "عدد الصفحات",
+                        "12",
+                        None,
+                        self.ui.COLORS['primary']
+                    )
+                
+                with col2:
+                    self.ui.create_metric_card(
+                        "عدد الكلمات",
+                        "2,450",
+                        None,
+                        self.ui.COLORS['secondary']
+                    )
+                
+                with col3:
+                    self.ui.create_metric_card(
+                        "وقت الترجمة",
+                        "45 ثانية",
+                        None,
+                        self.ui.COLORS['success']
+                    )
+                
+                with col4:
+                    self.ui.create_metric_card(
+                        "المصطلحات الفنية",
+                        "28",
+                        None,
+                        self.ui.COLORS['accent']
+                    )
+    
+    def technical_terms_dictionary(self):
+        """قاموس المصطلحات الفنية"""
+        st.markdown("### قاموس المصطلحات الفنية")
+        
+        # إضافة مصطلح جديد
+        with st.expander("إضافة مصطلح جديد"):
+            with st.form("add_term_form"):
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    term_ar = st.text_input("المصطلح بالعربية")
+                
+                with col2:
+                    term_en = st.text_input("المصطلح بالإنجليزية")
+                
+                with col3:
+                    term_category = st.selectbox(
+                        "الفئة",
+                        options=["مستندات", "ضمانات", "أنواع المناقصات", "عقود", "أطراف", "أعمال", "شروط", "أخرى"]
+                    )
+                
+                # زر إضافة المصطلح
+                submit_button = st.form_submit_button("إضافة المصطلح")
+                
+                if submit_button:
+                    if not term_ar or not term_en:
+                        st.error("يرجى ملء جميع الحقول المطلوبة")
+                    else:
+                        # في تطبيق حقيقي، سيتم إضافة المصطلح إلى قاعدة البيانات
+                        st.success("تمت إضافة المصطلح بنجاح")
+        
+        # البحث في المصطلحات
+        st.markdown("#### البحث في المصطلحات")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            search_term = st.text_input("البحث عن مصطلح")
+        
+        with col2:
+            search_language = st.radio(
+                "لغة البحث",
+                options=["الكل", "العربية", "الإنجليزية"],
+                horizontal=True
+            )
+        
+        with col3:
+            category_filter = st.selectbox(
+                "تصفية حسب الفئة",
+                options=["الكل", "مستندات", "ضمانات", "أنواع المناقصات", "عقود", "أطراف", "أعمال", "شروط", "أخرى"]
+            )
+        
+        # تطبيق الفلاتر
+        filtered_terms = self.technical_terms
+        
+        if search_term:
+            if search_language == "العربية":
+                filtered_terms = [term for term in filtered_terms if search_term.lower() in term["ar"].lower()]
+            elif search_language == "الإنجليزية":
+                filtered_terms = [term for term in filtered_terms if search_term.lower() in term["en"].lower()]
+            else:
+                filtered_terms = [term for term in filtered_terms if search_term.lower() in term["ar"].lower() or search_term.lower() in term["en"].lower()]
+        
+        if category_filter != "الكل":
+            filtered_terms = [term for term in filtered_terms if term["category"] == category_filter]
+        
+        # عرض المصطلحات
+        st.markdown("#### المصطلحات الفنية")
+        
+        if not filtered_terms:
+            st.info("لا توجد مصطلحات تطابق معايير البحث")
+        else:
+            # تحويل البيانات إلى DataFrame
+            terms_df = pd.DataFrame(filtered_terms)
+            
+            # إعادة تسمية الأعمدة
+            terms_df = terms_df.rename(columns={
+                "ar": "المصطلح بالعربية",
+                "en": "المصطلح بالإنجليزية",
+                "category": "الفئة"
+            })
+            
+            # عرض الجدول
+            st.dataframe(
+                terms_df,
+                use_container_width=True,
+                hide_index=True
+            )
+            
+            # أزرار إضافية
+            col1, col2 = st.columns([1, 5])
+            
+            with col1:
+                if st.button("تصدير القاموس", use_container_width=True):
+                    st.success("تم تصدير القاموس بنجاح")
+        
+        # عرض إحصائيات القاموس
+        st.markdown("#### إحصائيات القاموس")
+        
+        # حساب عدد المصطلحات في كل فئة
+        category_counts = {}
+        for term in self.technical_terms:
+            if term["category"] not in category_counts:
+                category_counts[term["category"]] = 0
+            category_counts[term["category"]] += 1
+        
+        # عرض الإحصائيات
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("##### عدد المصطلحات حسب الفئة")
+            
+            # تحويل البيانات إلى DataFrame
+            category_df = pd.DataFrame({
+                "الفئة": list(category_counts.keys()),
+                "العدد": list(category_counts.values())
+            })
+            
+            # عرض الرسم البياني
+            st.bar_chart(category_df.set_index("الفئة"))
+        
+        with col2:
+            st.markdown("##### إحصائيات عامة")
+            
+            total_terms = len(self.technical_terms)
+            categories_count = len(category_counts)
+            
+            st.markdown(f"**إجمالي المصطلحات:** {total_terms}")
+            st.markdown(f"**عدد الفئات:** {categories_count}")
+            st.markdown(f"**متوسط المصطلحات لكل فئة:** {total_terms / categories_count:.1f}")
+            st.markdown(f"**آخر تحديث للقاموس:** {datetime.datetime.now().strftime('%Y-%m-%d')}")
+    
+    def show_translated_documents(self):
+        """عرض المستندات المترجمة"""
+        st.markdown("### المستندات المترجمة")
+        
+        # إنشاء فلاتر للمستندات
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            entity_filter = st.selectbox(
+                "تصفية حسب الكيان",
+                options=["الكل"] + list(set([doc["related_entity"] for doc in self.translated_documents]))
+            )
+        
+        with col2:
+            language_pair_filter = st.selectbox(
+                "تصفية حسب زوج اللغات",
+                options=["الكل"] + list(set([f"{doc['source_language']} -> {doc['target_language']}" for doc in self.translated_documents]))
+            )
+        
+        with col3:
+            status_filter = st.selectbox(
+                "تصفية حسب الحالة",
+                options=["الكل", "مكتمل", "قيد التنفيذ"]
+            )
+        
+        # تطبيق الفلاتر
+        filtered_docs = self.translated_documents
+        
+        if entity_filter != "الكل":
+            filtered_docs = [doc for doc in filtered_docs if doc["related_entity"] == entity_filter]
+        
+        if language_pair_filter != "الكل":
+            source_lang, target_lang = language_pair_filter.split(" -> ")
+            filtered_docs = [doc for doc in filtered_docs if doc["source_language"] == source_lang and doc["target_language"] == target_lang]
+        
+        if status_filter != "الكل":
+            filtered_docs = [doc for doc in filtered_docs if doc["status"] == status_filter]
+        
+        # عرض المستندات المترجمة
+        if not filtered_docs:
+            st.info("لا توجد مستندات مترجمة تطابق معايير التصفية")
+        else:
+            # تحويل البيانات إلى DataFrame
+            docs_df = pd.DataFrame(filtered_docs)
+            
+            # تحويل رموز اللغات إلى أسماء اللغات
+            docs_df["source_language"] = docs_df["source_language"].map(self.supported_languages)
+            docs_df["target_language"] = docs_df["target_language"].map(self.supported_languages)
+            
+            # إعادة ترتيب الأعمدة وتغيير أسمائها
+            display_df = docs_df[[
+                "id", "name", "source_language", "target_language", "translation_date", "status", "pages", "related_entity"
+            ]].rename(columns={
+                "id": "الرقم",
+                "name": "اسم المستند",
+                "source_language": "لغة المصدر",
+                "target_language": "لغة الهدف",
+                "translation_date": "تاريخ الترجمة",
+                "status": "الحالة",
+                "pages": "عدد الصفحات",
+                "related_entity": "الكيان المرتبط"
+            })
+            
+            # عرض الجدول
+            st.dataframe(
+                display_df,
+                use_container_width=True,
+                hide_index=True
+            )
+            
+            # عرض تفاصيل المستند المحدد
+            st.markdown("#### تفاصيل المستند المترجم")
+            
+            selected_doc_id = st.selectbox(
+                "اختر مستنداً لعرض التفاصيل",
+                options=[doc["id"] for doc in filtered_docs],
+                format_func=lambda x: next((f"{doc['id']} - {doc['name']}" for doc in filtered_docs if doc["id"] == x), "")
+            )
+            
+            # العثور على المستند المحدد
+            selected_doc = next((doc for doc in filtered_docs if doc["id"] == selected_doc_id), None)
+            
+            if selected_doc:
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.markdown(f"**اسم المستند:** {selected_doc['name']}")
+                    st.markdown(f"**لغة المصدر:** {self.supported_languages[selected_doc['source_language']]}")
+                    st.markdown(f"**لغة الهدف:** {self.supported_languages[selected_doc['target_language']]}")
+                    st.markdown(f"**تاريخ الترجمة:** {selected_doc['translation_date']}")
+                
+                with col2:
+                    st.markdown(f"**الملف الأصلي:** {selected_doc['original_file']}")
+                    st.markdown(f"**الملف المترجم:** {selected_doc['translated_file']}")
+                    st.markdown(f"**المترجم:** {selected_doc['translated_by']}")
+                    st.markdown(f"**الحالة:** {selected_doc['status']}")
+                
+                # أزرار الإجراءات
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    if st.button("تنزيل الملف الأصلي", use_container_width=True):
+                        st.success("تم بدء تنزيل الملف الأصلي")
+                
+                with col2:
+                    if st.button("تنزيل الملف المترجم", use_container_width=True):
+                        st.success("تم بدء تنزيل الملف المترجم")
+                
+                with col3:
+                    if st.button("مشاركة الملف المترجم", use_container_width=True):
+                        st.success("تم نسخ رابط مشاركة الملف المترجم")
+        
+        # عرض إحصائيات الترجمة
+        st.markdown("#### إحصائيات الترجمة")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            # إحصائيات حسب زوج اللغات
+            language_pairs = {}
+            for doc in self.translated_documents:
+                pair = f"{self.supported_languages[doc['source_language']]} -> {self.supported_languages[doc['target_language']]}"
+                if pair not in language_pairs:
+                    language_pairs[pair] = 0
+                language_pairs[pair] += 1
+            
+            st.markdown("##### المستندات حسب زوج اللغات")
+            
+            # تحويل البيانات إلى DataFrame
+            language_df = pd.DataFrame({
+                "زوج اللغات": list(language_pairs.keys()),
+                "العدد": list(language_pairs.values())
+            })
+            
+            # عرض الرسم البياني
+            st.bar_chart(language_df.set_index("زوج اللغات"))
+        
+        with col2:
+            # إحصائيات حسب الكيان المرتبط
+            entity_counts = {}
+            for doc in self.translated_documents:
+                if doc["related_entity"] not in entity_counts:
+                    entity_counts[doc["related_entity"]] = 0
+                entity_counts[doc["related_entity"]] += 1
+            
+            st.markdown("##### المستندات حسب الكيان المرتبط")
+            
+            # تحويل البيانات إلى DataFrame
+            entity_df = pd.DataFrame({
+                "الكيان المرتبط": list(entity_counts.keys()),
+                "العدد": list(entity_counts.values())
+            })
+            
+            # عرض الرسم البياني
+            st.bar_chart(entity_df.set_index("الكيان المرتبط"))
+        
+        with col3:
+            # إحصائيات عامة
+            total_docs = len(self.translated_documents)
+            completed_docs = len([doc for doc in self.translated_documents if doc["status"] == "مكتمل"])
+            in_progress_docs = len([doc for doc in self.translated_documents if doc["status"] == "قيد التنفيذ"])
+            total_pages = sum([doc["pages"] for doc in self.translated_documents])
+            
+            st.markdown("##### إحصائيات عامة")
+            st.markdown(f"**إجمالي المستندات المترجمة:** {total_docs}")
+            st.markdown(f"**المستندات المكتملة:** {completed_docs}")
+            st.markdown(f"**المستندات قيد التنفيذ:** {in_progress_docs}")
+            st.markdown(f"**إجمالي الصفحات المترجمة:** {total_pages}")
+            st.markdown(f"**متوسط الصفحات لكل مستند:** {total_pages / total_docs:.1f}")
+
+# تشغيل التطبيق
+if __name__ == "__main__":
+    translation_app = TranslationApp()
+    translation_app.run()

styling/charts.py

@@ -0,0 +1,282 @@
+"""
+مولد الرسوم البيانية لنظام إدارة المناقصات
+"""
+
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
+import tkinter as tk
+import customtkinter as ctk
+
+class ChartGenerator:
+    """فئة مولد الرسوم البيانية"""
+    
+    def __init__(self, theme):
+        """تهيئة مولد الرسوم البيانية"""
+        self.theme = theme
+        
+        # تحديد مسار مجلد الرسوم البيانية
+        self.charts_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "data", "charts")
+        
+        # إنشاء مجلد الرسوم البيانية إذا لم يكن موجودًا
+        os.makedirs(self.charts_dir, exist_ok=True)
+        
+        # تهيئة نمط الرسوم البيانية
+        self._setup_chart_style()
+    
+    def _setup_chart_style(self):
+        """إعداد نمط الرسوم البيانية"""
+        # تعيين نمط الرسوم البيانية
+        plt.style.use('ggplot')
+        
+        # تعيين الخط
+        plt.rcParams['font.family'] = 'sans-serif'
+        plt.rcParams['font.sans-serif'] = ['Arial', 'DejaVu Sans', 'Liberation Sans', 'Bitstream Vera Sans', 'sans-serif']
+        
+        # تعيين حجم الخط
+        plt.rcParams['font.size'] = 10
+        plt.rcParams['axes.titlesize'] = 14
+        plt.rcParams['axes.labelsize'] = 12
+        plt.rcParams['xtick.labelsize'] = 10
+        plt.rcParams['ytick.labelsize'] = 10
+        plt.rcParams['legend.fontsize'] = 10
+        
+        # تعيين الألوان
+        if self.theme.current_theme == "light":
+            plt.rcParams['figure.facecolor'] = self.theme.LIGHT_CARD_BG_COLOR
+            plt.rcParams['axes.facecolor'] = self.theme.LIGHT_BG_COLOR
+            plt.rcParams['axes.edgecolor'] = self.theme.LIGHT_BORDER_COLOR
+            plt.rcParams['axes.labelcolor'] = self.theme.LIGHT_FG_COLOR
+            plt.rcParams['xtick.color'] = self.theme.LIGHT_FG_COLOR
+            plt.rcParams['ytick.color'] = self.theme.LIGHT_FG_COLOR
+            plt.rcParams['text.color'] = self.theme.LIGHT_FG_COLOR
+            plt.rcParams['grid.color'] = self.theme.LIGHT_BORDER_COLOR
+        else:
+            plt.rcParams['figure.facecolor'] = self.theme.DARK_CARD_BG_COLOR
+            plt.rcParams['axes.facecolor'] = self.theme.DARK_BG_COLOR
+            plt.rcParams['axes.edgecolor'] = self.theme.DARK_BORDER_COLOR
+            plt.rcParams['axes.labelcolor'] = self.theme.DARK_FG_COLOR
+            plt.rcParams['xtick.color'] = self.theme.DARK_FG_COLOR
+            plt.rcParams['ytick.color'] = self.theme.DARK_FG_COLOR
+            plt.rcParams['text.color'] = self.theme.DARK_FG_COLOR
+            plt.rcParams['grid.color'] = self.theme.DARK_BORDER_COLOR
+    
+    def create_bar_chart(self, data, title, xlabel, ylabel):
+        """إنشاء رسم بياني شريطي"""
+        # إنشاء الشكل والمحاور
+        fig, ax = plt.subplots(figsize=(8, 5), dpi=100)
+        
+        # رسم الرسم البياني الشريطي
+        bars = ax.bar(data['labels'], data['values'], color=self.theme.PRIMARY_COLOR[self.theme.current_theme])
+        
+        # إضافة القيم فوق الأشرطة
+        for bar in bars:
+            height = bar.get_height()
+            ax.text(bar.get_x() + bar.get_width() / 2., height + 0.1 * max(data['values']),
+                    f'{height:,.0f}', ha='center', va='bottom')
+        
+        # تعيين العنوان والتسميات
+        ax.set_title(title)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+        
+        # تعيين حدود المحور y
+        ax.set_ylim(0, max(data['values']) * 1.2)
+        
+        # إضافة الشبكة
+        ax.grid(True, linestyle='--', alpha=0.7)
+        
+        # تضييق الشكل
+        fig.tight_layout()
+        
+        return fig
+    
+    def create_line_chart(self, data, title, xlabel, ylabel):
+        """إنشاء رسم بياني خطي"""
+        # إنشاء الشكل والمحاور
+        fig, ax = plt.subplots(figsize=(8, 5), dpi=100)
+        
+        # رسم الرسم البياني الخطي
+        line = ax.plot(data['labels'], data['values'], marker='o', linestyle='-', linewidth=2,
+                      color=self.theme.PRIMARY_COLOR[self.theme.current_theme],
+                      markersize=8, markerfacecolor=self.theme.SECONDARY_COLOR[self.theme.current_theme])
+        
+        # إضافة القيم فوق النقاط
+        for i, value in enumerate(data['values']):
+            ax.text(i, value + 0.05 * max(data['values']), f'{value:,.0f}', ha='center', va='bottom')
+        
+        # تعيين العنوان والتسميات
+        ax.set_title(title)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+        
+        # تعيي�� حدود المحور y
+        ax.set_ylim(0, max(data['values']) * 1.2)
+        
+        # إضافة الشبكة
+        ax.grid(True, linestyle='--', alpha=0.7)
+        
+        # تضييق الشكل
+        fig.tight_layout()
+        
+        return fig
+    
+    def create_pie_chart(self, data, title):
+        """إنشاء رسم بياني دائري"""
+        # إنشاء الشكل والمحاور
+        fig, ax = plt.subplots(figsize=(8, 5), dpi=100)
+        
+        # تعيين الألوان
+        colors = [
+            self.theme.PRIMARY_COLOR[self.theme.current_theme],
+            self.theme.SECONDARY_COLOR[self.theme.current_theme],
+            self.theme.ACCENT_COLOR[self.theme.current_theme],
+            self.theme.WARNING_COLOR[self.theme.current_theme],
+            self.theme.SUCCESS_COLOR[self.theme.current_theme]
+        ]
+        
+        # رسم الرسم البياني الدائري
+        wedges, texts, autotexts = ax.pie(
+            data['values'],
+            labels=data['labels'],
+            autopct='%1.1f%%',
+            startangle=90,
+            colors=colors,
+            wedgeprops={'edgecolor': 'white', 'linewidth': 1},
+            textprops={'color': self.theme.get_color('fg_color')}
+        )
+        
+        # تعيين خصائص النص
+        for autotext in autotexts:
+            autotext.set_color('white')
+            autotext.set_fontweight('bold')
+        
+        # تعيين العنوان
+        ax.set_title(title)
+        
+        # جعل الرسم البياني دائريًا
+        ax.axis('equal')
+        
+        # تضييق الشكل
+        fig.tight_layout()
+        
+        return fig
+    
+    def create_stacked_bar_chart(self, data, title, xlabel, ylabel):
+        """إنشاء رسم بياني شريطي متراكم"""
+        # إنشاء الشكل والمحاور
+        fig, ax = plt.subplots(figsize=(8, 5), dpi=100)
+        
+        # تعيين الألوان
+        colors = [
+            self.theme.PRIMARY_COLOR[self.theme.current_theme],
+            self.theme.SECONDARY_COLOR[self.theme.current_theme],
+            self.theme.ACCENT_COLOR[self.theme.current_theme],
+            self.theme.WARNING_COLOR[self.theme.current_theme],
+            self.theme.SUCCESS_COLOR[self.theme.current_theme]
+        ]
+        
+        # رسم الرسم البياني الشريطي المتراكم
+        bottom = np.zeros(len(data['labels']))
+        for i, category in enumerate(data['categories']):
+            values = data['values'][i]
+            bars = ax.bar(data['labels'], values, bottom=bottom, label=category, color=colors[i % len(colors)])
+            bottom += values
+        
+        # تعيين العنوان والتسميات
+        ax.set_title(title)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+        
+        # إضافة وسيلة إيضاح
+        ax.legend()
+        
+        # إضافة الشبكة
+        ax.grid(True, linestyle='--', alpha=0.7)
+        
+        # تضييق الشكل
+        fig.tight_layout()
+        
+        return fig
+    
+    def create_risk_matrix(self, data, title):
+        """إنشاء مصفوفة المخاطر"""
+        # إنشاء الشكل والمحاور
+        fig, ax = plt.subplots(figsize=(8, 5), dpi=100)
+        
+        # تعيين الألوان
+        colors = {
+            'منخفض': self.theme.SUCCESS_COLOR[self.theme.current_theme],
+            'متوسط': self.theme.WARNING_COLOR[self.theme.current_theme],
+            'عالي': self.theme.ERROR_COLOR[self.theme.current_theme]
+        }
+        
+        # تعيين قيم المحاور
+        probability_values = {'منخفض': 1, 'متوسط': 2, 'عالي': 3}
+        impact_values = {'منخفض': 1, 'متوسط': 2, 'عالي': 3}
+        
+        # رسم المصفوفة
+        for risk in data['risks']:
+            prob = probability_values[risk['probability']]
+            impact = impact_values[risk['impact']]
+            color = colors[risk['probability']] if prob > impact else colors[risk['impact']]
+            ax.scatter(impact, prob, color=color, s=100, alpha=0.7)
+            ax.annotate(risk['name'], (impact, prob), xytext=(5, 5), textcoords='offset points')
+        
+        # تعيين حدود المحاور
+        ax.set_xlim(0.5, 3.5)
+        ax.set_ylim(0.5, 3.5)
+        
+        # تعيين تسميات المحاور
+        ax.set_xticks([1, 2, 3])
+        ax.set_xticklabels(['منخفض', 'متوسط', 'عالي'])
+        ax.set_yticks([1, 2, 3])
+        ax.set_yticklabels(['منخفض', 'متوسط', 'عالي'])
+        
+        # تعيين العنوان والتسميات
+        ax.set_title(title)
+        ax.set_xlabel('التأثير')
+        ax.set_ylabel('الاحتمالية')
+        
+        # إضافة الشبكة
+        ax.grid(True, linestyle='--', alpha=0.7)
+        
+        # إضافة مناطق المخاطر
+        # منطقة المخاطر المنخفضة (أخضر)
+        ax.add_patch(plt.Rectangle((0.5, 0.5), 1, 1, fill=True, color=self.theme.SUCCESS_COLOR[self.theme.current_theme], alpha=0.1))
+        # منطقة المخاطر المتوسطة (أصفر)
+        ax.add_patch(plt.Rectangle((1.5, 0.5), 1, 1, fill=True, color=self.theme.WARNING_COLOR[self.theme.current_theme], alpha=0.1))
+        ax.add_patch(plt.Rectangle((0.5, 1.5), 1, 1, fill=True, color=self.theme.WARNING_COLOR[self.theme.current_theme], alpha=0.1))
+        # منطقة المخاطر العالية (أحمر)
+        ax.add_patch(plt.Rectangle((2.5, 0.5), 1, 3, fill=True, color=self.theme.ERROR_COLOR[self.theme.current_theme], alpha=0.1))
+        ax.add_patch(plt.Rectangle((0.5, 2.5), 2, 1, fill=True, color=self.theme.ERROR_COLOR[self.theme.current_theme], alpha=0.1))
+        ax.add_patch(plt.Rectangle((1.5, 1.5), 1, 1, fill=True, color=self.theme.ERROR_COLOR[self.theme.current_theme], alpha=0.1))
+        
+        # تضييق الشكل
+        fig.tight_layout()
+        
+        return fig
+    
+    def embed_chart_in_frame(self, parent, fig):
+        """تضمين الرسم البياني في إطار"""
+        # إنشاء إطار للرسم البياني
+        chart_frame = ctk.CTkFrame(parent, fg_color="transparent")
+        
+        # تضمين الرسم البياني في الإطار
+        canvas = FigureCanvasTkAgg(fig, master=chart_frame)
+        canvas.draw()
+        canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
+        
+        return chart_frame
+    
+    def save_chart(self, fig, name):
+        """حفظ الرسم البياني"""
+        # تحديد مسار الملف
+        file_path = os.path.join(self.charts_dir, f"{name}.png")
+        
+        # حفظ الرسم البياني
+        fig.savefig(file_path, dpi=100, bbox_inches='tight')
+        
+        return file_path

styling/enhanced_ui.py

@@ -0,0 +1,582 @@
+"""
+محسن واجهة المستخدم - نظام تحليل المناقصات
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import base64
+from pathlib import Path
+import os
+
+class UIEnhancer:
+    """فئة لتحسين واجهة المستخدم وتوحيد التصميم عبر النظام"""
+    
+    # ألوان النظام
+    COLORS = {
+        'primary': '#1E88E5',      # أزرق
+        'secondary': '#5E35B1',    # بنفسجي
+        'success': '#43A047',      # أخضر
+        'warning': '#FB8C00',      # برتقالي
+        'danger': '#E53935',       # أحمر
+        'info': '#00ACC1',         # سماوي
+        'light': '#F5F5F5',        # رمادي فاتح
+        'dark': '#212121',         # رمادي داكن
+        'accent': '#FF4081',       # وردي
+        'background': '#FFFFFF',   # أبيض
+        'text': '#212121',         # أسود
+        'border': '#E0E0E0'        # رمادي حدود
+    }
+    
+    # أحجام الخطوط
+    FONT_SIZES = {
+        'xs': '0.75rem',
+        'sm': '0.875rem',
+        'md': '1rem',
+        'lg': '1.125rem',
+        'xl': '1.25rem',
+        '2xl': '1.5rem',
+        '3xl': '1.875rem',
+        '4xl': '2.25rem',
+        '5xl': '3rem'
+    }
+    
+    def __init__(self, page_title="نظام تحليل المناقصات", page_icon="📊"):
+        """تهيئة محسن واجهة المستخدم"""
+        self.page_title = page_title
+        self.page_icon = page_icon
+        self.theme_mode = "light"  # الوضع الافتراضي هو الوضع الفاتح
+        
+        # تهيئة متغير السمة في حالة الجلسة إذا لم يكن موجوداً
+        if 'theme' not in st.session_state:
+            st.session_state.theme = 'light'
+    
+    def apply_global_styles(self):
+        """تطبيق التنسيقات العامة على الصفحة"""
+        # تعريف CSS العام
+        css = f"""
+        @import url('https://fonts.googleapis.com/css2?family=Tajawal:wght@300;400;500;700&display=swap');
+        
+        * {{
+            font-family: 'Tajawal', sans-serif;
+            direction: rtl;
+        }}
+        
+        h1, h2, h3, h4, h5, h6 {{
+            font-family: 'Tajawal', sans-serif;
+            font-weight: 700;
+            color: {self.COLORS['dark']};
+        }}
+        
+        .module-title {{
+            color: {self.COLORS['primary']};
+            font-size: {self.FONT_SIZES['3xl']};
+            margin-bottom: 1rem;
+            border-bottom: 2px solid {self.COLORS['primary']};
+            padding-bottom: 0.5rem;
+        }}
+        
+        .stTabs [data-baseweb="tab-list"] {{
+            gap: 2px;
+        }}
+        
+        .stTabs [data-baseweb="tab"] {{
+            height: 50px;
+            white-space: pre-wrap;
+            background-color: {self.COLORS['light']};
+            border-radius: 4px 4px 0 0;
+            gap: 1px;
+            padding-top: 10px;
+            padding-bottom: 10px;
+        }}
+        
+        .stTabs [aria-selected="true"] {{
+            background-color: {self.COLORS['primary']};
+            color: white;
+        }}
+        
+        div[data-testid="stSidebarNav"] li div a span {{
+            direction: rtl;
+            text-align: right;
+            font-family: 'Tajawal', sans-serif;
+        }}
+        
+        div[data-testid="stSidebarNav"] {{
+            background-color: {self.COLORS['light']};
+        }}
+        
+        div[data-testid="stSidebarNav"] li div {{
+            margin-right: 0;
+            margin-left: auto;
+        }}
+        
+        div[data-testid="stSidebarNav"] li div a {{
+            padding-right: 10px;
+            padding-left: 0;
+        }}
+        
+        div[data-testid="stSidebarNav"] li div a:hover {{
+            background-color: {self.COLORS['primary'] + '20'};
+        }}
+        
+        div[data-testid="stSidebarNav"] li div[aria-selected="true"] {{
+            background-color: {self.COLORS['primary'] + '40'};
+        }}
+        
+        div[data-testid="stSidebarNav"] li div[aria-selected="true"] a span {{
+            color: {self.COLORS['primary']};
+            font-weight: 500;
+        }}
+        
+        .metric-card {{
+            background-color: white;
+            border-radius: 10px;
+            padding: 20px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            text-align: center;
+            transition: transform 0.3s ease;
+        }}
+        
+        .metric-card:hover {{
+            transform: translateY(-5px);
+        }}
+        
+        .metric-value {{
+            font-size: 2.5rem;
+            font-weight: 700;
+            margin: 10px 0;
+        }}
+        
+        .metric-label {{
+            font-size: 1rem;
+            color: #666;
+        }}
+        
+        .metric-change {{
+            font-size: 0.9rem;
+            margin-top: 5px;
+        }}
+        
+        .metric-change-positive {{
+            color: {self.COLORS['success']};
+        }}
+        
+        .metric-change-negative {{
+            color: {self.COLORS['danger']};
+        }}
+        
+        .custom-button {{
+            background-color: {self.COLORS['primary']};
+            color: white;
+            border: none;
+            border-radius: 5px;
+            padding: 10px 20px;
+            font-size: 1rem;
+            cursor: pointer;
+            transition: background-color 0.3s ease;
+        }}
+        
+        .custom-button:hover {{
+            background-color: {self.COLORS['secondary']};
+        }}
+        
+        .custom-card {{
+            background-color: white;
+            border-radius: 10px;
+            padding: 20px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            margin-bottom: 20px;
+        }}
+        
+        .header-container {{
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 2rem;
+            padding-bottom: 1rem;
+            border-bottom: 1px solid {self.COLORS['border']};
+        }}
+        
+        .header-title {{
+            color: {self.COLORS['primary']};
+            font-size: {self.FONT_SIZES['3xl']};
+            margin: 0;
+        }}
+        
+        .header-subtitle {{
+            color: {self.COLORS['dark']};
+            font-size: {self.FONT_SIZES['lg']};
+            margin: 0;
+        }}
+        
+        .header-actions {{
+            display: flex;
+            gap: 10px;
+        }}
+        
+        /* تنسيق الجداول */
+        div[data-testid="stTable"] table {{
+            width: 100%;
+            border-collapse: collapse;
+        }}
+        
+        div[data-testid="stTable"] thead tr th {{
+            background-color: {self.COLORS['primary']};
+            color: white;
+            text-align: right;
+            padding: 12px;
+        }}
+        
+        div[data-testid="stTable"] tbody tr:nth-child(even) {{
+            background-color: {self.COLORS['light']};
+        }}
+        
+        div[data-testid="stTable"] tbody tr:hover {{
+            background-color: {self.COLORS['primary'] + '10'};
+        }}
+        
+        div[data-testid="stTable"] tbody tr td {{
+            padding: 10px;
+            text-align: right;
+        }}
+        
+        /* تنسيق النماذج */
+        div[data-testid="stForm"] {{
+            background-color: white;
+            border-radius: 10px;
+            padding: 20px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }}
+        
+        button[kind="primaryFormSubmit"] {{
+            background-color: {self.COLORS['primary']};
+            color: white;
+        }}
+        
+        button[kind="secondaryFormSubmit"] {{
+            background-color: {self.COLORS['light']};
+            color: {self.COLORS['dark']};
+            border: 1px solid {self.COLORS['border']};
+        }}
+        
+        /* تنسيق الرسوم البيانية */
+        div[data-testid="stVegaLiteChart"] {{
+            background-color: white;
+            border-radius: 10px;
+            padding: 20px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }}
+        """
+        
+        # تطبيق CSS
+        st.markdown(f'<style>{css}</style>', unsafe_allow_html=True)
+    
+    def apply_theme_colors(self):
+        """تطبيق ألوان السمة الحالية"""
+        # تحديد ألوان السمة بناءً على الوضع
+        if self.theme_mode == "dark":
+            self.COLORS['background'] = '#121212'
+            self.COLORS['text'] = '#FFFFFF'
+            self.COLORS['border'] = '#333333'
+        else:
+            self.COLORS['background'] = '#FFFFFF'
+            self.COLORS['text'] = '#212121'
+            self.COLORS['border'] = '#E0E0E0'
+        
+        # تطبيق CSS للسمة
+        theme_css = f"""
+        body {{
+            background-color: {self.COLORS['background']};
+            color: {self.COLORS['text']};
+        }}
+        """
+        
+        st.markdown(f'<style>{theme_css}</style>', unsafe_allow_html=True)
+    
+    def toggle_theme(self):
+        """تبديل وضع السمة بين الفاتح والداكن"""
+        if self.theme_mode == "light":
+            self.theme_mode = "dark"
+        else:
+            self.theme_mode = "light"
+        
+        self.apply_theme_colors()
+    
+    def create_sidebar(self, menu_items):
+        """إنشاء الشريط الجانبي مع قائمة العناصر"""
+        with st.sidebar:
+            # إضافة الشعار
+            st.markdown(
+                f"""
+                <div style="text-align: center; margin-bottom: 20px;">
+                    <h2 style="color: {self.COLORS['primary']};">{self.page_icon} {self.page_title}</h2>
+                </div>
+                """,
+                unsafe_allow_html=True
+            )
+            
+            # إضافة معلومات المستخدم
+            st.markdown(
+                f"""
+                <div style="text-align: center; margin-bottom: 20px;">
+                    <div style="width: 60px; height: 60px; border-radius: 50%; background-color: {self.COLORS['primary']}; color: white; display: flex; align-items: center; justify-content: center; margin: 0 auto; font-size: 24px; font-weight: bold;">
+                        م
+                    </div>
+                    <p style="margin-top: 10px; font-weight: bold;">مهندس تامر الجوهري</p>
+                    <p style="margin-top: -15px; font-size: 0.8rem; color: #666;">مدير المشاريع</p>
+                </div>
+                """,
+                unsafe_allow_html=True
+            )
+            
+            st.divider()
+            
+            # إنشاء القائمة
+            selected = st.radio(
+                "القائمة الرئيسية",
+                [item["name"] for item in menu_items],
+                format_func=lambda x: x,
+                label_visibility="collapsed"
+            )
+            
+            st.divider()
+            
+            # إضافة معلومات النظام
+            st.markdown(
+                """
+                <div style="position: absolute; bottom: 20px; left: 20px; right: 20px; text-align: center;">
+                    <p style="font-size: 0.8rem; color: #666;">نظام تحليل المناقصات | الإصدار 2.0.0</p>
+                    <p style="font-size: 0.7rem; color: #888;">© 2025 جميع الحقوق محفوظة</p>
+                </div>
+                """,
+                unsafe_allow_html=True
+            )
+        
+        return selected
+    
+    def create_header(self, title, subtitle=None, show_actions=True):
+        """إنشاء ترويسة الصفحة"""
+        # إنشاء معرفات فريدة للأزرار
+        add_button_key = f"add_button_{title}"
+        update_button_key = f"update_button_{title}"
+        
+        col1, col2 = st.columns([3, 1])
+        
+        with col1:
+            st.markdown(f'<h1 class="header-title">{title}</h1>', unsafe_allow_html=True)
+            if subtitle:
+                st.markdown(f'<p class="header-subtitle">{subtitle}</p>', unsafe_allow_html=True)
+        
+        if show_actions:
+            with col2:
+                col2_1, col2_2 = st.columns(2)
+                with col2_1:
+                    st.button("إضافة جديد", key=add_button_key)
+                with col2_2:
+                    st.button("تحديث", key=update_button_key)
+        
+        st.divider()
+    
+    def create_metric_card(self, label, value, change=None, color=None):
+        """إنشاء بطاقة مقياس"""
+        if color is None:
+            color = self.COLORS['primary']
+        
+        change_html = ""
+        if change is not None:
+            if change.startswith("+"):
+                change_class = "metric-change-positive"
+                change_icon = "↑"
+            elif change.startswith("-"):
+                change_class = "metric-change-negative"
+                change_icon = "↓"
+            else:
+                change_class = ""
+                change_icon = ""
+            
+            change_html = f'<div class="metric-change {change_class}">{change_icon} {change}</div>'
+        
+        st.markdown(
+            f"""
+            <div class="metric-card" style="border-top: 4px solid {color};">
+                <div class="metric-label">{label}</div>
+                <div class="metric-value" style="color: {color};">{value}</div>
+                {change_html}
+            </div>
+            """,
+            unsafe_allow_html=True
+        )
+    
+    def create_card(self, title, content, color=None):
+        """إنشاء بطاقة عامة"""
+        if color is None:
+            color = self.COLORS['primary']
+        
+        st.markdown(
+            f"""
+            <div class="custom-card" style="border-top: 4px solid {color};">
+                <h3 style="color: {color}; margin-top: 0;">{title}</h3>
+                <div>{content}</div>
+            </div>
+            """,
+            unsafe_allow_html=True
+        )
+    
+    def create_button(self, label, color=None, icon=None, key=None):
+        """إنشاء زر مخصص"""
+        if color is None:
+            color = self.COLORS['primary']
+        
+        # إنشاء معرف فريد للزر إذا لم يتم توفيره
+        if key is None:
+            key = f"button_{label}_{hash(label)}"
+        
+        icon_html = f"{icon} " if icon else ""
+        
+        return st.button(
+            f"{icon_html}{label}",
+            key=key
+        )
+    
+    def create_tabs(self, tab_names):
+        """إنشاء تبويبات"""
+        return st.tabs(tab_names)
+    
+    def create_expander(self, title, expanded=False, key=None):
+        """إنشاء عنصر قابل للتوسيع"""
+        # إنشاء معرف فريد للعنصر إذا لم يتم توفيره
+        if key is None:
+            key = f"expander_{title}_{hash(title)}"
+        
+        return st.expander(title, expanded=expanded, key=key)
+    
+    def create_data_table(self, data, use_container_width=True, hide_index=True):
+        """إنشاء جدول بيانات"""
+        return st.dataframe(data, use_container_width=use_container_width, hide_index=hide_index)
+    
+    def create_chart(self, chart_type, data, **kwargs):
+        """إنشاء رسم بياني"""
+        if chart_type == "bar":
+            return st.bar_chart(data, **kwargs)
+        elif chart_type == "line":
+            return st.line_chart(data, **kwargs)
+        elif chart_type == "area":
+            return st.area_chart(data, **kwargs)
+        else:
+            return st.bar_chart(data, **kwargs)
+    
+    def create_form(self, title, key=None):
+        """إنشاء نموذج"""
+        # إنشاء معرف فريد للنموذج إذا لم يتم توفيره
+        if key is None:
+            key = f"form_{title}_{hash(title)}"
+        
+        return st.form(key=key)
+    
+    def create_file_uploader(self, label, types=None, key=None):
+        """إنشاء أداة رفع الملفات"""
+        # إنشاء معرف فريد لأداة رفع الملفات إذا لم يتم توفيره
+        if key is None:
+            key = f"file_uploader_{label}_{hash(label)}"
+        
+        return st.file_uploader(label, type=types, key=key)
+    
+    def create_date_input(self, label, value=None, key=None):
+        """إنشاء حقل إدخال تاريخ"""
+        # إنشاء معرف فريد لحقل إدخال التاريخ إذا لم يتم توفيره
+        if key is None:
+            key = f"date_input_{label}_{hash(label)}"
+        
+        return st.date_input(label, value=value, key=key)
+    
+    def create_select_box(self, label, options, index=0, key=None):
+        """إنشاء قائمة منسدلة"""
+        # إنشاء معرف فريد للقائمة المنسدلة إذا لم يتم توفيره
+        if key is None:
+            key = f"select_box_{label}_{hash(label)}"
+        
+        return st.selectbox(label, options, index=index, key=key)
+    
+    def create_multi_select(self, label, options, default=None, key=None):
+        """إنشاء قائمة اختيار متعدد"""
+        # إنشاء معرف فريد لقائمة الاختيار المتعدد إذا لم يتم توفيره
+        if key is None:
+            key = f"multi_select_{label}_{hash(label)}"
+        
+        return st.multiselect(label, options, default=default, key=key)
+    
+    def create_slider(self, label, min_value, max_value, value=None, step=1, key=None):
+        """إنشاء شريط تمرير"""
+        # إنشاء معرف فريد لشريط التمرير إذا لم يتم توفيره
+        if key is None:
+            key = f"slider_{label}_{hash(label)}"
+        
+        return st.slider(label, min_value=min_value, max_value=max_value, value=value, step=step, key=key)
+    
+    def create_text_input(self, label, value="", key=None):
+        """إنشاء حقل إدخال نصي"""
+        # إنشاء معرف فريد لحقل الإدخال النصي إذا لم يتم توفيره
+        if key is None:
+            key = f"text_input_{label}_{hash(label)}"
+        
+        return st.text_input(label, value=value, key=key)
+    
+    def create_text_area(self, label, value="", height=None, key=None):
+        """إنشاء منطقة نص"""
+        # إنشاء معرف فريد لمنطقة النص إذا لم يتم توفيره
+        if key is None:
+            key = f"text_area_{label}_{hash(label)}"
+        
+        return st.text_area(label, value=value, height=height, key=key)
+    
+    def create_number_input(self, label, min_value=None, max_value=None, value=0, step=1, key=None):
+        """إنشاء حقل إدخال رقمي"""
+        # إنشاء معرف فريد لحقل الإدخال الرقمي إذا لم يتم توفيره
+        if key is None:
+            key = f"number_input_{label}_{hash(label)}"
+        
+        return st.number_input(label, min_value=min_value, max_value=max_value, value=value, step=step, key=key)
+    
+    def create_checkbox(self, label, value=False, key=None):
+        """إنشاء خانة اختيار"""
+        # إنشاء معرف فريد لخانة الاختيار إذا لم يتم توفيره
+        if key is None:
+            key = f"checkbox_{label}_{hash(label)}"
+        
+        return st.checkbox(label, value=value, key=key)
+    
+    def create_radio(self, label, options, index=0, key=None):
+        """إنشاء أزرار راديو"""
+        # إنشاء معرف فريد لأزرار الراديو إذا لم يتم توفيره
+        if key is None:
+            key = f"radio_{label}_{hash(label)}"
+        
+        return st.radio(label, options, index=index, key=key)
+    
+    def create_progress_bar(self, value, key=None):
+        """إنشاء شريط تقدم"""
+        # إنشاء معرف فريد لشريط التقدم إذا لم يتم توفيره
+        if key is None:
+            key = f"progress_bar_{value}_{hash(str(value))}"
+        
+        return st.progress(value, key=key)
+    
+    def create_spinner(self, text="جاري التحميل..."):
+        """إنشاء مؤشر تحميل"""
+        return st.spinner(text)
+    
+    def create_success_message(self, message):
+        """إنشاء رسالة نجاح"""
+        return st.success(message)
+    
+    def create_error_message(self, message):
+        """إنشاء رسالة خطأ"""
+        return st.error(message)
+    
+    def create_warning_message(self, message):
+        """إنشاء رسالة تحذير"""
+        return st.warning(message)
+    
+    def create_info_message(self, message):
+        """إنشاء رسالة معلومات"""
+        return st.info(message)

styling/icons.py

@@ -0,0 +1,609 @@
+"""
+مولد الأيقونات لنظام إدارة المناقصات
+"""
+
+import os
+import math
+from PIL import Image, ImageDraw, ImageFont
+
+class IconGenerator:
+    """فئة مولد الأيقونات"""
+    
+    def __init__(self):
+        """تهيئة مولد الأيقونات"""
+        # تحديد مسار مجلد الأيقونات
+        self.icons_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "assets", "icons")
+        
+        # إنشاء مجلد الأيقونات إذا لم يكن موجودًا
+        os.makedirs(self.icons_dir, exist_ok=True)
+        
+        # تحديد حجم الأيقونة الافتراضي
+        self.icon_size = (64, 64)
+        
+        # تحديد الألوان الافتراضية
+        self.colors = {
+            "primary": "#2980B9",
+            "secondary": "#1ABC9C",
+            "accent": "#9B59B6",
+            "warning": "#F39C12",
+            "error": "#E74C3C",
+            "success": "#2ECC71",
+            "white": "#FFFFFF",
+            "black": "#333333",
+            "gray": "#95A5A6"
+        }
+    
+    def generate_icon(self, name, color=None, background_color=None, size=None):
+        """توليد أيقونة"""
+        # تحديد الألوان
+        if color is None:
+            color = self.colors["primary"]
+        
+        if background_color is None:
+            background_color = self.colors["white"]
+        
+        # تحديد الحجم
+        if size is None:
+            size = self.icon_size
+        
+        # إنشاء صورة جديدة
+        icon = Image.new("RGBA", size, background_color)
+        draw = ImageDraw.Draw(icon)
+        
+        # رسم الأيقونة بناءً على الاسم
+        if name == "dashboard":
+            self._draw_dashboard_icon(draw, size, color)
+        elif name == "projects":
+            self._draw_projects_icon(draw, size, color)
+        elif name == "documents":
+            self._draw_documents_icon(draw, size, color)
+        elif name == "pricing":
+            self._draw_pricing_icon(draw, size, color)
+        elif name == "resources":
+            self._draw_resources_icon(draw, size, color)
+        elif name == "risk":
+            self._draw_risk_icon(draw, size, color)
+        elif name == "reports":
+            self._draw_reports_icon(draw, size, color)
+        elif name == "ai":
+            self._draw_ai_icon(draw, size, color)
+        elif name == "settings":
+            self._draw_settings_icon(draw, size, color)
+        elif name == "logout":
+            self._draw_logout_icon(draw, size, color)
+        elif name == "search":
+            self._draw_search_icon(draw, size, color)
+        elif name == "add":
+            self._draw_add_icon(draw, size, color)
+        elif name == "upload":
+            self._draw_upload_icon(draw, size, color)
+        elif name == "import":
+            self._draw_import_icon(draw, size, color)
+        elif name == "export":
+            self._draw_export_icon(draw, size, color)
+        elif name == "save":
+            self._draw_save_icon(draw, size, color)
+        else:
+            # أيقونة افتراضية
+            self._draw_default_icon(draw, size, color)
+        
+        # حفظ الأيقونة
+        icon_path = os.path.join(self.icons_dir, f"{name}.png")
+        icon.save(icon_path)
+        
+        return icon_path
+    
+    def _draw_dashboard_icon(self, draw, size, color):
+        """رسم أيقونة لوحة التحكم"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم المربعات الأربعة
+        box_size = (width - 3 * padding) // 2
+        
+        # المربع العلوي الأيسر
+        draw.rectangle(
+            [(padding, padding), (padding + box_size, padding + box_size)],
+            fill=color
+        )
+        
+        # المربع العلوي الأيمن
+        draw.rectangle(
+            [(2 * padding + box_size, padding), (2 * padding + 2 * box_size, padding + box_size)],
+            fill=color
+        )
+        
+        # المربع السفلي الأيسر
+        draw.rectangle(
+            [(padding, 2 * padding + box_size), (padding + box_size, 2 * padding + 2 * box_size)],
+            fill=color
+        )
+        
+        # المربع السفلي الأيمن
+        draw.rectangle(
+            [(2 * padding + box_size, 2 * padding + box_size), (2 * padding + 2 * box_size, 2 * padding + 2 * box_size)],
+            fill=color
+        )
+    
+    def _draw_projects_icon(self, draw, size, color):
+        """رسم أيقونة المشاريع"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم مجلد
+        folder_points = [
+            (padding, height // 3),
+            (width // 3, height // 3),
+            (width // 2, padding),
+            (width - padding, padding),
+            (width - padding, height - padding),
+            (padding, height - padding)
+        ]
+        draw.polygon(folder_points, fill=color)
+    
+    def _draw_documents_icon(self, draw, size, color):
+        """رسم أيقونة المستندات"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم ورقة
+        draw.rectangle(
+            [(padding, padding), (width - padding, height - padding)],
+            fill=color
+        )
+        
+        # رسم خطوط النص
+        line_padding = height // 8
+        line_height = height // 20
+        for i in range(4):
+            y = padding + line_padding + i * (line_height + line_padding)
+            draw.rectangle(
+                [(padding * 2, y), (width - padding * 2, y + line_height)],
+                fill=self.colors["white"]
+            )
+    
+    def _draw_pricing_icon(self, draw, size, color):
+        """رسم أيقونة التسعير"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم علامة الدولار
+        center_x = width // 2
+        center_y = height // 2
+        radius = min(width, height) // 3
+        
+        # رسم دائرة
+        draw.ellipse(
+            [(center_x - radius, center_y - radius), (center_x + radius, center_y + radius)],
+            fill=color
+        )
+        
+        # رسم علامة الدولار
+        line_width = radius // 4
+        draw.rectangle(
+            [(center_x - line_width // 2, center_y - radius * 2 // 3), (center_x + line_width // 2, center_y + radius * 2 // 3)],
+            fill=self.colors["white"]
+        )
+        draw.rectangle(
+            [(center_x - radius * 2 // 3, center_y - line_width // 2), (center_x + radius * 2 // 3, center_y + line_width // 2)],
+            fill=self.colors["white"]
+        )
+    
+    def _draw_resources_icon(self, draw, size, color):
+        """رسم أيقونة الموارد"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم ثلاثة أشخاص
+        center_x = width // 2
+        center_y = height // 2
+        radius = min(width, height) // 10
+        
+        # الشخص الأول (في الوسط)
+        head_center_y = center_y - radius * 2
+        draw.ellipse(
+            [(center_x - radius, head_center_y - radius), (center_x + radius, head_center_y + radius)],
+            fill=color
+        )
+        draw.polygon(
+            [
+                (center_x, head_center_y + radius),
+                (center_x - radius * 2, center_y + radius * 3),
+                (center_x + radius * 2, center_y + radius * 3)
+            ],
+            fill=color
+        )
+        
+        # الشخص الثاني (على اليسار)
+        left_center_x = center_x - radius * 4
+        head_center_y = center_y - radius * 2
+        draw.ellipse(
+            [(left_center_x - radius, head_center_y - radius), (left_center_x + radius, head_center_y + radius)],
+            fill=color
+        )
+        draw.polygon(
+            [
+                (left_center_x, head_center_y + radius),
+                (left_center_x - radius * 2, center_y + radius * 3),
+                (left_center_x + radius * 2, center_y + radius * 3)
+            ],
+            fill=color
+        )
+        
+        # الشخص الثالث (على اليمين)
+        right_center_x = center_x + radius * 4
+        head_center_y = center_y - radius * 2
+        draw.ellipse(
+            [(right_center_x - radius, head_center_y - radius), (right_center_x + radius, head_center_y + radius)],
+            fill=color
+        )
+        draw.polygon(
+            [
+                (right_center_x, head_center_y + radius),
+                (right_center_x - radius * 2, center_y + radius * 3),
+                (right_center_x + radius * 2, center_y + radius * 3)
+            ],
+            fill=color
+        )
+    
+    def _draw_risk_icon(self, draw, size, color):
+        """رسم أيقونة المخاطر"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم علامة تحذير (مثلث)
+        draw.polygon(
+            [
+                (width // 2, padding),
+                (padding, height - padding),
+                (width - padding, height - padding)
+            ],
+            fill=color
+        )
+        
+        # رسم علامة التعجب
+        exclamation_width = width // 10
+        exclamation_height = height // 3
+        center_x = width // 2
+        center_y = height // 2
+        
+        # الجزء العلوي من علامة التعجب
+        draw.rectangle(
+            [
+                (center_x - exclamation_width // 2, center_y - exclamation_height),
+                (center_x + exclamation_width // 2, center_y)
+            ],
+            fill=self.colors["white"]
+        )
+        
+        # النقطة السفلية من علامة التعجب
+        dot_radius = exclamation_width
+        draw.ellipse(
+            [
+                (center_x - dot_radius // 2, center_y + exclamation_height // 4),
+                (center_x + dot_radius // 2, center_y + exclamation_height // 4 + dot_radius)
+            ],
+            fill=self.colors["white"]
+        )
+    
+    def _draw_reports_icon(self, draw, size, color):
+        """رسم أيقونة التقارير"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم ورقة
+        draw.rectangle(
+            [(padding, padding), (width - padding, height - padding)],
+            fill=color
+        )
+        
+        # رسم رسم بياني
+        chart_padding = width // 6
+        chart_width = width - 2 * chart_padding
+        chart_height = height // 2
+        chart_bottom = height - chart_padding
+        
+        # رسم الأعمدة
+        bar_width = chart_width // 5
+        bar_spacing = bar_width // 2
+        
+        for i in range(4):
+            bar_height = (i + 1) * chart_height // 4
+            bar_x = chart_padding + i * (bar_width + bar_spacing)
+            bar_y = chart_bottom - bar_height
+            
+            draw.rectangle(
+                [(bar_x, bar_y), (bar_x + bar_width, chart_bottom)],
+                fill=self.colors["white"]
+            )
+    
+    def _draw_ai_icon(self, draw, size, color):
+        """رسم أيقونة الذكاء الاصطناعي"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم دماغ (مجرد تمثيل مبسط)
+        center_x = width // 2
+        center_y = height // 2
+        brain_width = width - 2 * padding
+        brain_height = height - 2 * padding
+        
+        # رسم الجزء الخارجي من الدماغ
+        draw.ellipse(
+            [(center_x - brain_width // 2, center_y - brain_height // 2), (center_x + brain_width // 2, center_y + brain_height // 2)],
+            fill=color
+        )
+        
+        # رسم خطوط الدماغ
+        line_width = brain_width // 10
+        line_spacing = brain_width // 8
+        
+        for i in range(-2, 3):
+            y = center_y + i * line_spacing
+            draw.line(
+                [(center_x - brain_width // 3, y), (center_x + brain_width // 3, y)],
+                fill=self.colors["white"],
+                width=line_width
+            )
+    
+    def _draw_settings_icon(self, draw, size, color):
+        """رسم أيقونة الإعدادات"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم ترس
+        center_x = width // 2
+        center_y = height // 2
+        outer_radius = min(width, height) // 2 - padding
+        inner_radius = outer_radius * 2 // 3
+        
+        # رسم الدائرة الداخلية
+        draw.ellipse(
+            [(center_x - inner_radius, center_y - inner_radius), (center_x + inner_radius, center_y + inner_radius)],
+            fill=color
+        )
+        
+        # رسم الأسنان
+        num_teeth = 8
+        tooth_width = outer_radius - inner_radius
+        
+        for i in range(num_teeth):
+            angle = 2 * math.pi * i / num_teeth
+            tooth_center_x = center_x + (inner_radius + tooth_width // 2) * math.cos(angle)
+            tooth_center_y = center_y + (inner_radius + tooth_width // 2) * math.sin(angle)
+            
+            draw.ellipse(
+                [
+                    (tooth_center_x - tooth_width // 2, tooth_center_y - tooth_width // 2),
+                    (tooth_center_x + tooth_width // 2, tooth_center_y + tooth_width // 2)
+                ],
+                fill=color
+            )
+    
+    def _draw_logout_icon(self, draw, size, color):
+        """رسم أيقونة تسجيل الخروج"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم سهم الخروج
+        arrow_width = width - 2 * padding
+        arrow_height = height - 2 * padding
+        
+        # رسم المستطيل الرئيسي
+        draw.rectangle(
+            [(padding, padding), (width // 2, height - padding)],
+            fill=color
+        )
+        
+        # رسم السهم
+        arrow_points = [
+            (width // 2, height // 3),
+            (width - padding, height // 2),
+            (width // 2, height * 2 // 3),
+            (width // 2, height // 2 + height // 8),
+            (width // 2 + width // 4, height // 2 + height // 8),
+            (width // 2 + width // 4, height // 2 - height // 8),
+            (width // 2, height // 2 - height // 8)
+        ]
+        draw.polygon(arrow_points, fill=color)
+    
+    def _draw_search_icon(self, draw, size, color):
+        """رسم أيقونة البحث"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم دائرة البحث
+        center_x = width // 2 - padding
+        center_y = height // 2 - padding
+        radius = min(width, height) // 3
+        
+        draw.ellipse(
+            [(center_x - radius, center_y - radius), (center_x + radius, center_y + radius)],
+            outline=color,
+            width=radius // 3
+        )
+        
+        # رسم مقبض البحث
+        handle_width = radius // 3
+        handle_length = radius
+        handle_angle = math.pi / 4  # 45 درجة
+        
+        handle_start_x = center_x + radius * math.cos(handle_angle)
+        handle_start_y = center_y + radius * math.sin(handle_angle)
+        handle_end_x = handle_start_x + handle_length * math.cos(handle_angle)
+        handle_end_y = handle_start_y + handle_length * math.sin(handle_angle)
+        
+        draw.line(
+            [(handle_start_x, handle_start_y), (handle_end_x, handle_end_y)],
+            fill=color,
+            width=handle_width
+        )
+    
+    def _draw_add_icon(self, draw, size, color):
+        """رسم أيقونة الإضافة"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم علامة الزائد
+        center_x = width // 2
+        center_y = height // 2
+        line_length = min(width, height) - 2 * padding
+        line_width = line_length // 5
+        
+        # الخط الأفقي
+        draw.rectangle(
+            [
+                (center_x - line_length // 2, center_y - line_width // 2),
+                (center_x + line_length // 2, center_y + line_width // 2)
+            ],
+            fill=color
+        )
+        
+        # الخط الرأسي
+        draw.rectangle(
+            [
+                (center_x - line_width // 2, center_y - line_length // 2),
+                (center_x + line_width // 2, center_y + line_length // 2)
+            ],
+            fill=color
+        )
+    
+    def _draw_upload_icon(self, draw, size, color):
+        """رسم أيقونة التحميل"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم سهم لأعلى
+        center_x = width // 2
+        arrow_width = width // 3
+        arrow_height = height // 2
+        
+        # رسم السهم
+        arrow_points = [
+            (center_x, padding),
+            (center_x + arrow_width, padding + arrow_height),
+            (center_x + arrow_width // 2, padding + arrow_height),
+            (center_x + arrow_width // 2, height - padding),
+            (center_x - arrow_width // 2, height - padding),
+            (center_x - arrow_width // 2, padding + arrow_height),
+            (center_x - arrow_width, padding + arrow_height)
+        ]
+        draw.polygon(arrow_points, fill=color)
+    
+    def _draw_import_icon(self, draw, size, color):
+        """رسم أيقونة الاستيراد"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم سهم للداخل
+        center_y = height // 2
+        arrow_width = width // 2
+        arrow_height = height // 3
+        
+        # رسم المستطيل
+        draw.rectangle(
+            [(width - padding - arrow_width // 2, padding), (width - padding, height - padding)],
+            fill=color
+        )
+        
+        # رسم السهم
+        arrow_points = [
+            (padding, center_y),
+            (padding + arrow_width, center_y - arrow_height // 2),
+            (padding + arrow_width, center_y - arrow_height // 4),
+            (width - padding - arrow_width // 2, center_y - arrow_height // 4),
+            (width - padding - arrow_width // 2, center_y + arrow_height // 4),
+            (padding + arrow_width, center_y + arrow_height // 4),
+            (padding + arrow_width, center_y + arrow_height // 2)
+        ]
+        draw.polygon(arrow_points, fill=color)
+    
+    def _draw_export_icon(self, draw, size, color):
+        """رسم أيقونة التصدير"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم سهم للخارج
+        center_y = height // 2
+        arrow_width = width // 2
+        arrow_height = height // 3
+        
+        # رسم المستطيل
+        draw.rectangle(
+            [(padding, padding), (padding + arrow_width // 2, height - padding)],
+            fill=color
+        )
+        
+        # رسم السهم
+        arrow_points = [
+            (width - padding, center_y),
+            (width - padding - arrow_width, center_y - arrow_height // 2),
+            (width - padding - arrow_width, center_y - arrow_height // 4),
+            (padding + arrow_width // 2, center_y - arrow_height // 4),
+            (padding + arrow_width // 2, center_y + arrow_height // 4),
+            (width - padding - arrow_width, center_y + arrow_height // 4),
+            (width - padding - arrow_width, center_y + arrow_height // 2)
+        ]
+        draw.polygon(arrow_points, fill=color)
+    
+    def _draw_save_icon(self, draw, size, color):
+        """رسم أيقونة الحفظ"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم أيقونة القرص
+        draw.rectangle(
+            [(padding, padding), (width - padding, height - padding)],
+            fill=color
+        )
+        
+        # رسم الشريط العلوي
+        draw.rectangle(
+            [(padding * 2, padding * 2), (width - padding * 2, padding * 4)],
+            fill=self.colors["white"]
+        )
+        
+        # رسم المستطيل الداخلي
+        draw.rectangle(
+            [(width // 3, height // 2), (width * 2 // 3, height - padding * 2)],
+            fill=self.colors["white"]
+        )
+    
+    def _draw_default_icon(self, draw, size, color):
+        """رسم أيقونة افتراضية"""
+        width, height = size
+        padding = width // 8
+        
+        # رسم دائرة
+        center_x = width // 2
+        center_y = height // 2
+        radius = min(width, height) // 2 - padding
+        
+        draw.ellipse(
+            [(center_x - radius, center_y - radius), (center_x + radius, center_y + radius)],
+            fill=color
+        )
+    
+    def generate_default_icons(self):
+        """توليد الأيقونات الافتراضية"""
+        icons = [
+            "dashboard",
+            "projects",
+            "documents",
+            "pricing",
+            "resources",
+            "risk",
+            "reports",
+            "ai",
+            "settings",
+            "logout",
+            "search",
+            "add",
+            "upload",
+            "import",
+            "export",
+            "save"
+        ]
+        
+        for icon in icons:
+            self.generate_icon(icon)

styling/theme.py

@@ -0,0 +1,541 @@
+"""
+ملف النمط لنظام إدارة المناقصات
+"""
+
+import os
+import tkinter as tk
+import customtkinter as ctk
+from PIL import Image, ImageDraw
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
+
+class AppTheme:
+    """فئة نمط التطبيق"""
+    
+    # ألوان النمط الفاتح
+    LIGHT_BG_COLOR = "#F5F5F5"
+    LIGHT_FG_COLOR = "#333333"
+    LIGHT_CARD_BG_COLOR = "#FFFFFF"
+    LIGHT_SIDEBAR_BG_COLOR = "#2C3E50"
+    LIGHT_SIDEBAR_FG_COLOR = "#FFFFFF"
+    LIGHT_SIDEBAR_HOVER_COLOR = "#34495E"
+    LIGHT_SIDEBAR_ACTIVE_COLOR = "#1ABC9C"
+    LIGHT_BUTTON_BG_COLOR = "#2980B9"
+    LIGHT_BUTTON_HOVER_COLOR = "#3498DB"
+    LIGHT_BUTTON_ACTIVE_COLOR = "#1F618D"
+    LIGHT_INPUT_BG_COLOR = "#FFFFFF"
+    LIGHT_INPUT_FG_COLOR = "#333333"
+    LIGHT_BORDER_COLOR = "#E0E0E0"
+    
+    # ألوان النمط الداكن
+    DARK_BG_COLOR = "#121212"
+    DARK_FG_COLOR = "#E0E0E0"
+    DARK_CARD_BG_COLOR = "#1E1E1E"
+    DARK_SIDEBAR_BG_COLOR = "#1A1A2E"
+    DARK_SIDEBAR_FG_COLOR = "#E0E0E0"
+    DARK_SIDEBAR_HOVER_COLOR = "#16213E"
+    DARK_SIDEBAR_ACTIVE_COLOR = "#0F3460"
+    DARK_BUTTON_BG_COLOR = "#0F3460"
+    DARK_BUTTON_HOVER_COLOR = "#16213E"
+    DARK_BUTTON_ACTIVE_COLOR = "#1A1A2E"
+    DARK_INPUT_BG_COLOR = "#2C2C2C"
+    DARK_INPUT_FG_COLOR = "#E0E0E0"
+    DARK_BORDER_COLOR = "#333333"
+    
+    # ألوان الأساسية
+    PRIMARY_COLOR = {
+        "light": "#2980B9",
+        "dark": "#0F3460"
+    }
+    
+    SECONDARY_COLOR = {
+        "light": "#1ABC9C",
+        "dark": "#16213E"
+    }
+    
+    ACCENT_COLOR = {
+        "light": "#9B59B6",
+        "dark": "#533483"
+    }
+    
+    WARNING_COLOR = {
+        "light": "#F39C12",
+        "dark": "#E58E26"
+    }
+    
+    ERROR_COLOR = {
+        "light": "#E74C3C",
+        "dark": "#C0392B"
+    }
+    
+    SUCCESS_COLOR = {
+        "light": "#2ECC71",
+        "dark": "#27AE60"
+    }
+    
+    def __init__(self, config):
+        """تهيئة النمط"""
+        self.config = config
+        self.current_theme = self.config.get_theme()
+        self.font_family = self.config.get_font()
+        self.font_size = self.config.get_font_size()
+        
+        # تهيئة النمط
+        self._setup_theme()
+    
+    def _setup_theme(self):
+        """إعداد النمط"""
+        # تعيين نمط customtkinter
+        ctk.set_appearance_mode(self.current_theme)
+        ctk.set_default_color_theme("blue")
+        
+        # تهيئة الخطوط
+        self.fonts = {
+            "title": (self.font_family, self.font_size + 8, "bold"),
+            "subtitle": (self.font_family, self.font_size + 4, "bold"),
+            "heading": (self.font_family, self.font_size + 2, "bold"),
+            "body": (self.font_family, self.font_size, "normal"),
+            "small": (self.font_family, self.font_size - 2, "normal")
+        }
+    
+    def apply_theme_to_app(self, app):
+        """تطبيق النمط على التطبيق"""
+        app.configure(fg_color=self.get_color("bg_color"))
+    
+    def get_color(self, color_name):
+        """الحصول على لون معين"""
+        if self.current_theme == "light":
+            colors = {
+                "bg_color": self.LIGHT_BG_COLOR,
+                "fg_color": self.LIGHT_FG_COLOR,
+                "card_bg_color": self.LIGHT_CARD_BG_COLOR,
+                "sidebar_bg_color": self.LIGHT_SIDEBAR_BG_COLOR,
+                "sidebar_fg_color": self.LIGHT_SIDEBAR_FG_COLOR,
+                "sidebar_hover_color": self.LIGHT_SIDEBAR_HOVER_COLOR,
+                "sidebar_active_color": self.LIGHT_SIDEBAR_ACTIVE_COLOR,
+                "button_bg_color": self.LIGHT_BUTTON_BG_COLOR,
+                "button_hover_color": self.LIGHT_BUTTON_HOVER_COLOR,
+                "button_active_color": self.LIGHT_BUTTON_ACTIVE_COLOR,
+                "input_bg_color": self.LIGHT_INPUT_BG_COLOR,
+                "input_fg_color": self.LIGHT_INPUT_FG_COLOR,
+                "border_color": self.LIGHT_BORDER_COLOR,
+                "primary_color": self.PRIMARY_COLOR["light"],
+                "secondary_color": self.SECONDARY_COLOR["light"],
+                "accent_color": self.ACCENT_COLOR["light"],
+                "warning_color": self.WARNING_COLOR["light"],
+                "error_color": self.ERROR_COLOR["light"],
+                "success_color": self.SUCCESS_COLOR["light"]
+            }
+        else:
+            colors = {
+                "bg_color": self.DARK_BG_COLOR,
+                "fg_color": self.DARK_FG_COLOR,
+                "card_bg_color": self.DARK_CARD_BG_COLOR,
+                "sidebar_bg_color": self.DARK_SIDEBAR_BG_COLOR,
+                "sidebar_fg_color": self.DARK_SIDEBAR_FG_COLOR,
+                "sidebar_hover_color": self.DARK_SIDEBAR_HOVER_COLOR,
+                "sidebar_active_color": self.DARK_SIDEBAR_ACTIVE_COLOR,
+                "button_bg_color": self.DARK_BUTTON_BG_COLOR,
+                "button_hover_color": self.DARK_BUTTON_HOVER_COLOR,
+                "button_active_color": self.DARK_BUTTON_ACTIVE_COLOR,
+                "input_bg_color": self.DARK_INPUT_BG_COLOR,
+                "input_fg_color": self.DARK_INPUT_FG_COLOR,
+                "border_color": self.DARK_BORDER_COLOR,
+                "primary_color": self.PRIMARY_COLOR["dark"],
+                "secondary_color": self.SECONDARY_COLOR["dark"],
+                "accent_color": self.ACCENT_COLOR["dark"],
+                "warning_color": self.WARNING_COLOR["dark"],
+                "error_color": self.ERROR_COLOR["dark"],
+                "success_color": self.SUCCESS_COLOR["dark"]
+            }
+        
+        return colors.get(color_name, self.LIGHT_BG_COLOR)
+    
+    def get_font(self, font_type):
+        """الحصول على خط معين"""
+        return self.fonts.get(font_type, self.fonts["body"])
+    
+    def toggle_theme(self):
+        """تبديل النمط بين الفاتح والداكن"""
+        if self.current_theme == "light":
+            self.current_theme = "dark"
+        else:
+            self.current_theme = "light"
+        
+        # تحديث النمط في الإعدادات
+        self.config.set_theme(self.current_theme)
+        
+        # تحديث نمط customtkinter
+        ctk.set_appearance_mode(self.current_theme)
+        
+        return self.current_theme
+    
+    def create_styled_frame(self, parent, **kwargs):
+        """إنشاء إطار منسق"""
+        default_kwargs = {
+            "fg_color": self.get_color("bg_color"),
+            "corner_radius": 10,
+            "border_width": 0
+        }
+        
+        # دمج الخصائص المخصصة مع الخصائص الافتراضية
+        for key, value in kwargs.items():
+            default_kwargs[key] = value
+        
+        return ctk.CTkFrame(parent, **default_kwargs)
+    
+    def create_styled_scrollable_frame(self, parent, **kwargs):
+        """إنشاء إطار قابل للتمرير منسق"""
+        default_kwargs = {
+            "fg_color": self.get_color("bg_color"),
+            "corner_radius": 10,
+            "border_width": 0
+        }
+        
+        # دمج الخصائص المخصصة مع الخصائص الافتراضية
+        for key, value in kwargs.items():
+            default_kwargs[key] = value
+        
+        return ctk.CTkScrollableFrame(parent, **default_kwargs)
+    
+    def create_styled_label(self, parent, text, **kwargs):
+        """إنشاء تسمية منسقة"""
+        default_kwargs = {
+            "text": text,
+            "font": self.get_font("body"),
+            "text_color": self.get_color("fg_color")
+        }
+        
+        # دمج الخصائص المخصصة مع الخصائص الافتراضية
+        for key, value in kwargs.items():
+            default_kwargs[key] = value
+        
+        return ctk.CTkLabel(parent, **default_kwargs)
+    
+    def create_styled_button(self, parent, text, **kwargs):
+        """إنشاء زر منسق"""
+        default_kwargs = {
+            "text": text,
+            "font": self.get_font("body"),
+            "fg_color": self.get_color("button_bg_color"),
+            "hover_color": self.get_color("button_hover_color"),
+            "text_color": "white",
+            "corner_radius": 8,
+            "border_width": 0,
+            "height": 36
+        }
+        
+        # إضافة أيقونة إذا تم تحديدها
+        if "icon" in kwargs:
+            icon_name = kwargs.pop("icon")
+            # هنا يمكن إضافة منطق لتحميل الأيقونة
+        
+        # دمج الخصائص المخصصة مع الخصائص الافتراضية
+        for key, value in kwargs.items():
+            default_kwargs[key] = value
+        
+        return ctk.CTkButton(parent, **default_kwargs)
+    
+    def create_styled_entry(self, parent, placeholder_text, **kwargs):
+        """إنشاء حقل إدخال منسق"""
+        default_kwargs = {
+            "placeholder_text": placeholder_text,
+            "font": self.get_font("body"),
+            "fg_color": self.get_color("input_bg_color"),
+            "text_color": self.get_color("input_fg_color"),
+            "placeholder_text_color": self.get_color("border_color"),
+            "corner_radius": 8,
+            "border_width": 1,
+            "border_color": self.get_color("border_color"),
+            "height": 36
+        }
+        
+        # دمج الخصائص المخصصة مع الخصائص الافتراضية
+        for key, value in kwargs.items():
+            default_kwargs[key] = value
+        
+        return ctk.CTkEntry(parent, **default_kwargs)
+    
+    def create_styled_textbox(self, parent, **kwargs):
+        """إنشاء مربع نص منسق"""
+        default_kwargs = {
+            "font": self.get_font("body"),
+            "fg_color": self.get_color("input_bg_color"),
+            "text_color": self.get_color("input_fg_color"),
+            "corner_radius": 8,
+            "border_width": 1,
+            "border_color": self.get_color("border_color")
+        }
+        
+        # دمج الخصائص المخصصة مع الخصائص الافتراضية
+        for key, value in kwargs.items():
+            default_kwargs[key] = value
+        
+        return ctk.CTkTextbox(parent, **default_kwargs)
+    
+    def create_styled_combobox(self, parent, values, **kwargs):
+        """إنشاء قائمة منسدلة منسقة"""
+        default_kwargs = {
+            "values": values,
+            "font": self.get_font("body"),
+            "fg_color": self.get_color("input_bg_color"),
+            "text_color": self.get_color("input_fg_color"),
+            "border_color": self.get_color("border_color"),
+            "button_color": self.get_color("button_bg_color"),
+            "button_hover_color": self.get_color("button_hover_color"),
+            "dropdown_fg_color": self.get_color("card_bg_color"),
+            "dropdown_text_color": self.get_color("fg_color"),
+            "dropdown_hover_color": self.get_color("sidebar_hover_color"),
+            "corner_radius": 8,
+            "border_width": 1,
+            "dropdown_font": self.get_font("body")
+        }
+        
+        # دمج الخصائص المخصصة مع الخصائص الافتراضية
+        for key, value in kwargs.items():
+            default_kwargs[key] = value
+        
+        return ctk.CTkComboBox(parent, **default_kwargs)
+    
+    def create_styled_switch(self, parent, text, **kwargs):
+        """إنشاء مفتاح تبديل منسق"""
+        default_kwargs = {
+            "text": text,
+            "font": self.get_font("body"),
+            "fg_color": self.get_color("border_color"),
+            "progress_color": self.get_color("button_bg_color"),
+            "button_color": "white",
+            "button_hover_color": "white",
+            "text_color": self.get_color("fg_color")
+        }
+        
+        # دمج الخصائص المخصصة مع الخصائص الافتراضية
+        for key, value in kwargs.items():
+            default_kwargs[key] = value
+        
+        return ctk.CTkSwitch(parent, **default_kwargs)
+    
+    def create_styled_radio_button(self, parent, text, variable, value, **kwargs):
+        """إنشاء زر راديو منسق"""
+        default_kwargs = {
+            "text": text,
+            "font": self.get_font("body"),
+            "fg_color": self.get_color("button_bg_color"),
+            "border_color": self.get_color("border_color"),
+            "hover_color": self.get_color("button_hover_color"),
+            "text_color": self.get_color("fg_color"),
+            "variable": variable,
+            "value": value
+        }
+        
+        # دمج الخصائص المخصصة مع الخصائص الافتراضية
+        for key, value in kwargs.items():
+            default_kwargs[key] = value
+        
+        return ctk.CTkRadioButton(parent, **default_kwargs)
+    
+    def create_styled_slider(self, parent, **kwargs):
+        """إنشاء شريط تمرير منسق"""
+        default_kwargs = {
+            "fg_color": self.get_color("border_color"),
+            "progress_color": self.get_color("button_bg_color"),
+            "button_color": self.get_color("button_bg_color"),
+            "button_hover_color": self.get_color("button_hover_color")
+        }
+        
+        # دمج الخصائص المخصصة مع الخصائص الافتراضية
+        for key, value in kwargs.items():
+            default_kwargs[key] = value
+        
+        return ctk.CTkSlider(parent, **default_kwargs)
+    
+    def create_styled_tabview(self, parent, **kwargs):
+        """إنشاء عرض تبويب منسق"""
+        default_kwargs = {
+            "fg_color": self.get_color("card_bg_color"),
+            "segmented_button_fg_color": self.get_color("sidebar_bg_color"),
+            "segmented_button_selected_color": self.get_color("button_bg_color"),
+            "segmented_button_unselected_color": self.get_color("sidebar_bg_color"),
+            "segmented_button_selected_hover_color": self.get_color("button_hover_color"),
+            "segmented_button_unselected_hover_color": self.get_color("sidebar_hover_color"),
+            "segmented_button_text_color": self.get_color("sidebar_fg_color"),
+            "segmented_button_selected_text_color": "white",
+            "text_color": self.get_color("fg_color"),
+            "corner_radius": 10
+        }
+        
+        # دمج الخصائص المخصصة مع الخصائص الافتراضية
+        for key, value in kwargs.items():
+            default_kwargs[key] = value
+        
+        return ctk.CTkTabview(parent, **default_kwargs)
+    
+    def create_styled_sidebar_button(self, parent, text, icon, command=None):
+        """إنشاء زر الشريط الجانبي المنسق"""
+        # إنشاء إطار للزر
+        button_frame = ctk.CTkFrame(
+            parent,
+            fg_color="transparent",
+            corner_radius=0
+        )
+        
+        # إنشاء الزر
+        button = ctk.CTkButton(
+            button_frame,
+            text=text,
+            font=self.get_font("body"),
+            fg_color="transparent",
+            hover_color=self.get_color("sidebar_hover_color"),
+            text_color=self.get_color("sidebar_fg_color"),
+            anchor="w",
+            corner_radius=0,
+            border_width=0,
+            height=40,
+            command=command
+        )
+        button.pack(fill="x", padx=0, pady=0)
+        
+        return button_frame, button
+    
+    def create_styled_card(self, parent, title):
+        """إنشاء بطاقة منسقة"""
+        # إنشاء إطار البطاقة
+        card = self.create_styled_frame(
+            parent,
+            fg_color=self.get_color("card_bg_color")
+        )
+        
+        # إنشاء عنوان البطاقة
+        title_label = self.create_styled_label(
+            card,
+            title,
+            font=self.get_font("heading")
+        )
+        title_label.pack(anchor="w", padx=15, pady=(15, 5))
+        
+        # إنشاء خط فاصل
+        separator = ctk.CTkFrame(
+            card,
+            height=1,
+            fg_color=self.get_color("border_color")
+        )
+        separator.pack(fill="x", padx=15, pady=(5, 0))
+        
+        # إنشاء إطار المحتوى
+        content_frame = self.create_styled_frame(
+            card,
+            fg_color="transparent"
+        )
+        content_frame.pack(fill="both", expand=True, padx=15, pady=15)
+        
+        return card, content_frame
+    
+    def create_styled_data_table(self, parent, columns, data):
+        """إنشاء جدول بيانات منسق"""
+        # إنشاء إطار الجدول
+        table_frame = self.create_styled_frame(
+            parent,
+            fg_color="transparent"
+        )
+        
+        # إنشاء إطار العناوين
+        header_frame = self.create_styled_frame(
+            table_frame,
+            fg_color=self.get_color("sidebar_bg_color")
+        )
+        header_frame.pack(fill="x", padx=0, pady=(0, 1))
+        
+        # إنشاء عناوين الأعمدة
+        for i, column in enumerate(columns):
+            column_label = self.create_styled_label(
+                header_frame,
+                column,
+                font=self.get_font("heading"),
+                text_color=self.get_color("sidebar_fg_color")
+            )
+            column_label.grid(row=0, column=i, sticky="ew", padx=10, pady=10)
+            header_frame.grid_columnconfigure(i, weight=1)
+        
+        # إنشاء إطار البيانات
+        data_frame = self.create_styled_scrollable_frame(
+            table_frame,
+            fg_color="transparent"
+        )
+        data_frame.pack(fill="both", expand=True, padx=0, pady=0)
+        
+        # إنشاء صفوف البيانات
+        for i, row in enumerate(data):
+            row_frame = self.create_styled_frame(
+                data_frame,
+                fg_color=self.get_color("card_bg_color") if i % 2 == 0 else self.get_color("bg_color")
+            )
+            row_frame.pack(fill="x", padx=0, pady=(0, 1))
+            
+            for j, cell in enumerate(row):
+                cell_label = self.create_styled_label(
+                    row_frame,
+                    cell,
+                    font=self.get_font("body")
+                )
+                cell_label.grid(row=0, column=j, sticky="ew", padx=10, pady=10)
+                row_frame.grid_columnconfigure(j, weight=1)
+        
+        return table_frame, data_frame
+    
+    def create_styled_message_box(self, title, message, message_type="info"):
+        """إنشاء مربع رسالة منسق"""
+        # تحديد لون الرسالة بناءً على النوع
+        if message_type == "error":
+            color = self.get_color("error_color")
+        elif message_type == "warning":
+            color = self.get_color("warning_color")
+        elif message_type == "success":
+            color = self.get_color("success_color")
+        else:  # info
+            color = self.get_color("primary_color")
+        
+        # إنشاء نافذة الرسالة
+        message_window = ctk.CTkToplevel()
+        message_window.title(title)
+        message_window.geometry("400x200")
+        message_window.resizable(False, False)
+        message_window.grab_set()  # جعل النافذة المنبثقة مركز الاهتمام
+        
+        # تطبيق النمط
+        message_window.configure(fg_color=self.get_color("bg_color"))
+        
+        # إنشاء إطار الرسالة
+        message_frame = self.create_styled_frame(
+            message_window,
+            fg_color=self.get_color("card_bg_color")
+        )
+        message_frame.pack(fill="both", expand=True, padx=20, pady=20)
+        
+        # إنشاء عنوان الرسالة
+        title_label = self.create_styled_label(
+            message_frame,
+            title,
+            font=self.get_font("heading"),
+            text_color=color
+        )
+        title_label.pack(padx=20, pady=(20, 10))
+        
+        # إنشاء نص الرسالة
+        message_label = self.create_styled_label(
+            message_frame,
+            message,
+            font=self.get_font("body")
+        )
+        message_label.pack(padx=20, pady=(0, 20))
+        
+        # إنشاء زر موافق
+        ok_button = self.create_styled_button(
+            message_frame,
+            "موافق",
+            fg_color=color,
+            hover_color=color,
+            command=message_window.destroy
+        )
+        ok_button.pack(pady=(0, 20))
+        
+        return message_window

tests/test_app.py

@@ -0,0 +1,601 @@
+"""
+وحدة اختبار التطبيق لنظام إدارة المناقصات - Hybrid Face
+"""
+
+import os
+import sys
+import logging
+import unittest
+import tkinter as tk
+from pathlib import Path
+
+# تهيئة السجل
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger('test_app')
+
+# إضافة المسار الرئيسي للتطبيق إلى مسار البحث
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# استيراد الوحدات المطلوبة للاختبار
+from database.db_connector import DatabaseConnector
+from database.models import User, Project, Document, ProjectItem, Resource, Risk, Report, SystemLog
+from modules.document_analysis.analyzer import DocumentAnalyzer
+from modules.pricing.pricing_engine import PricingEngine
+from modules.risk_analysis.risk_analyzer import RiskAnalyzer
+from modules.ai_assistant.assistant import AIAssistant
+from styling.theme import AppTheme
+from styling.icons import IconGenerator
+from styling.charts import ChartGenerator
+from config import AppConfig
+
+class TestDatabaseConnector(unittest.TestCase):
+    """اختبار وحدة اتصال قاعدة البيانات"""
+    
+    def setUp(self):
+        """إعداد بيئة الاختبار"""
+        # استخدام قاعدة بيانات اختبار مؤقتة
+        self.config = AppConfig()
+        self.config.DB_NAME = "test_tender_system.db"
+        self.db = DatabaseConnector(self.config)
+    
+    def tearDown(self):
+        """تنظيف بيئة الاختبار"""
+        self.db.disconnect()
+        # حذف قاعدة البيانات المؤقتة
+        if os.path.exists(self.config.DB_NAME):
+            os.remove(self.config.DB_NAME)
+    
+    def test_connection(self):
+        """اختبار الاتصال بقاعدة البيانات"""
+        self.assertTrue(self.db.is_connected)
+    
+    def test_execute_query(self):
+        """اختبار تنفيذ استعلام"""
+        cursor = self.db.execute("SELECT 1")
+        self.assertIsNotNone(cursor)
+        result = cursor.fetchone()
+        self.assertEqual(result[0], 1)
+    
+    def test_insert_and_fetch(self):
+        """اختبار إدراج واسترجاع البيانات"""
+        # إدراج بيانات
+        user_data = {
+            "username": "test_user",
+            "password": "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918",  # admin
+            "full_name": "مستخدم اختبار",
+            "email": "[email protected]",
+            "role": "user"
+        }
+        user_id = self.db.insert("users", user_data)
+        self.assertIsNotNone(user_id)
+        
+        # استرجاع البيانات
+        user = self.db.fetch_one("SELECT * FROM users WHERE id = ?", (user_id,))
+        self.assertIsNotNone(user)
+        self.assertEqual(user["username"], "test_user")
+        self.assertEqual(user["full_name"], "مستخدم اختبار")
+    
+    def test_update(self):
+        """اختبار تحديث البيانات"""
+        # إدراج بيانات
+        user_data = {
+            "username": "update_user",
+            "password": "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918",  # admin
+            "full_name": "مستخدم للتحديث",
+            "email": "[email protected]",
+            "role": "user"
+        }
+        user_id = self.db.insert("users", user_data)
+        
+        # تحديث البيانات
+        updated_data = {
+            "full_name": "مستخدم تم تحديثه",
+            "role": "admin"
+        }
+        rows_affected = self.db.update("users", updated_data, "id = ?", (user_id,))
+        self.assertEqual(rows_affected, 1)
+        
+        # التحقق من التحديث
+        user = self.db.fetch_one("SELECT * FROM users WHERE id = ?", (user_id,))
+        self.assertEqual(user["full_name"], "مستخدم تم تحديثه")
+        self.assertEqual(user["role"], "admin")
+    
+    def test_delete(self):
+        """اختبار حذف البيانات"""
+        # إدراج بيانات
+        user_data = {
+            "username": "delete_user",
+            "password": "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918",  # admin
+            "full_name": "مستخدم للحذف",
+            "email": "[email protected]",
+            "role": "user"
+        }
+        user_id = self.db.insert("users", user_data)
+        
+        # حذف البيانات
+        rows_affected = self.db.delete("users", "id = ?", (user_id,))
+        self.assertEqual(rows_affected, 1)
+        
+        # التحقق من الحذف
+        user = self.db.fetch_one("SELECT * FROM users WHERE id = ?", (user_id,))
+        self.assertIsNone(user)
+
+
+class TestModels(unittest.TestCase):
+    """اختبار نماذج البيانات"""
+    
+    def setUp(self):
+        """��عداد بيئة الاختبار"""
+        # استخدام قاعدة بيانات اختبار مؤقتة
+        self.config = AppConfig()
+        self.config.DB_NAME = "test_models.db"
+        self.db = DatabaseConnector(self.config)
+    
+    def tearDown(self):
+        """تنظيف بيئة الاختبار"""
+        self.db.disconnect()
+        # حذف قاعدة البيانات المؤقتة
+        if os.path.exists(self.config.DB_NAME):
+            os.remove(self.config.DB_NAME)
+    
+    def test_user_model(self):
+        """اختبار نموذج المستخدم"""
+        # إنشاء مستخدم جديد
+        user = User(self.db)
+        user.data = {
+            "username": "model_user",
+            "password": "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918",  # admin
+            "full_name": "مستخدم نموذج",
+            "email": "[email protected]",
+            "role": "user",
+            "is_active": 1
+        }
+        
+        # حفظ المستخدم
+        self.assertTrue(user.save())
+        self.assertIsNotNone(user.data.get("id"))
+        
+        # استرجاع المستخدم
+        retrieved_user = User.get_by_id(user.data["id"], self.db)
+        self.assertIsNotNone(retrieved_user)
+        self.assertEqual(retrieved_user.data["username"], "model_user")
+        
+        # مصادقة المستخدم
+        authenticated_user = User.authenticate("model_user", "admin", self.db)
+        self.assertIsNotNone(authenticated_user)
+        self.assertEqual(authenticated_user.data["username"], "model_user")
+        
+        # تعيين كلمة مرور جديدة
+        user.set_password("newpassword")
+        user.save()
+        
+        # مصادقة المستخدم بكلمة المرور الجديدة
+        authenticated_user = User.authenticate("model_user", "newpassword", self.db)
+        self.assertIsNotNone(authenticated_user)
+        
+        # حذف المستخدم
+        self.assertTrue(user.delete())
+    
+    def test_project_model(self):
+        """اختبار نموذج المشروع"""
+        # إنشاء مستخدم للمشروع
+        user = User(self.db)
+        user.data = {
+            "username": "project_user",
+            "password": "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918",  # admin
+            "full_name": "مستخدم المشروع",
+            "email": "[email protected]",
+            "role": "user",
+            "is_active": 1
+        }
+        user.save()
+        
+        # إنشاء مشروع جديد
+        project = Project(self.db)
+        project.data = {
+            "name": "مشروع اختبار",
+            "client": "عميل اختبار",
+            "description": "وصف مشروع الاختبار",
+            "start_date": "2025-01-01",
+            "end_date": "2025-12-31",
+            "status": "تخطيط",
+            "created_by": user.data["id"]
+        }
+        
+        # حفظ المشروع
+        self.assertTrue(project.save())
+        self.assertIsNotNone(project.data.get("id"))
+        
+        # استرجاع المشروع
+        retrieved_project = Project.get_by_id(project.data["id"], self.db)
+        self.assertIsNotNone(retrieved_project)
+        self.assertEqual(retrieved_project.data["name"], "مشروع اختبار")
+        
+        # إضافة بند للمشروع
+        item = ProjectItem(self.db)
+        item.data = {
+            "project_id": project.data["id"],
+            "name": "بند اختبار",
+            "description": "وصف بند الاختبار",
+            "unit": "م²",
+            "quantity": 100,
+            "unit_price": 500,
+            "total_price": 50000
+        }
+        item.save()
+        
+        # حساب التكلفة الإجمالية للمشروع
+        total_cost = project.calculate_total_cost()
+        self.assertEqual(total_cost, 50000)
+        
+        # حذف المشروع
+        self.assertTrue(project.delete())
+        
+        # حذف المستخدم
+        self.assertTrue(user.delete())
+
+
+class TestDocumentAnalyzer(unittest.TestCase):
+    """اختبار محلل المستندات"""
+    
+    def setUp(self):
+        """إعداد بيئة الاختبار"""
+        self.config = AppConfig()
+        self.analyzer = DocumentAnalyzer(self.config)
+        
+        # إنشاء مجلد المستندات للاختبار
+        self.test_docs_dir = Path("test_documents")
+        self.test_docs_dir.mkdir(exist_ok=True)
+        
+        # إنشاء ملف مستند اختبار
+        self.test_doc_path = self.test_docs_dir / "test_document.txt"
+        with open(self.test_doc_path, "w", encoding="utf-8") as f:
+            f.write("هذا مستند اختبار لمحلل المستندات")
+    
+    def tearDown(self):
+        """تنظيف بيئة الاختبار"""
+        # حذف ملف المستند
+        if self.test_doc_path.exists():
+            self.test_doc_path.unlink()
+        
+        # حذف مجلد المستندات
+        if self.test_docs_dir.exists():
+            self.test_docs_dir.rmdir()
+    
+    def test_analyze_document(self):
+        """اختبار تحليل المستند"""
+        # تحليل المستند
+        result = self.analyzer.analyze_document(str(self.test_doc_path), "tender")
+        self.assertTrue(result)
+        
+        # انتظار اكتمال التحليل
+        import time
+        max_wait = 5  # ثوانٍ
+        waited = 0
+        while self.analyzer.analysis_in_progress and waited < max_wait:
+            time.sleep(0.5)
+            waited += 0.5
+        
+        # التحقق من نتائج التحليل
+        self.assertFalse(self.analyzer.analysis_in_progress)
+        results = self.analyzer.get_analysis_results()
+        self.assertEqual(results["status"], "اكتمل التحليل")
+        self.assertEqual(results["document_path"], str(self.test_doc_path))
+    
+    def test_export_analysis_results(self):
+        """اختبار تصدير نتائج التحليل"""
+        # تحليل المستند
+        self.analyzer.analyze_document(str(self.test_doc_path), "tender")
+        
+        # انتظار اكتمال التحليل
+        import time
+        max_wait = 5  # ثوانٍ
+        waited = 0
+        while self.analyzer.analysis_in_progress and waited < max_wait:
+            time.sleep(0.5)
+            waited += 0.5
+        
+        # تصدير النتائج
+        export_path = self.test_docs_dir / "analysis_results.json"
+        result_path = self.analyzer.export_analysis_results(str(export_path))
+        self.assertIsNotNone(result_path)
+        
+        # التحقق من وجود ملف التصدير
+        self.assertTrue(export_path.exists())
+        
+        # حذف ملف التصدير
+        if export_path.exists():
+            export_path.unlink()
+
+
+class TestPricingEngine(unittest.TestCase):
+    """اختبار محرك التسعير"""
+    
+    def setUp(self):
+        """إعداد بيئة الاختبار"""
+        self.config = AppConfig()
+        self.pricing_engine = PricingEngine(self.config)
+    
+    def test_calculate_pricing(self):
+        """اختبار حساب التسعير"""
+        # حساب التسعير
+        result = self.pricing_engine.calculate_pricing(1, "comprehensive")
+        self.assertTrue(result)
+        
+        # انتظار اكتمال التسعير
+        import time
+        max_wait = 5  # ثوانٍ
+        waited = 0
+        while self.pricing_engine.pricing_in_progress and waited < max_wait:
+            time.sleep(0.5)
+            waited += 0.5
+        
+        # التحقق من نتائج التسعير
+        self.assertFalse(self.pricing_engine.pricing_in_progress)
+        results = self.pricing_engine.get_pricing_results()
+        self.assertEqual(results["status"], "اكتمل التسعير")
+        self.assertEqual(results["project_id"], 1)
+        self.assertEqual(results["strategy"], "comprehensive")
+        
+        # التحقق من وجود التكاليف المباشرة
+        self.assertIn("direct_costs", results)
+        self.assertIn("total_direct_costs", results["direct_costs"])
+        
+        # التحقق من وجود التكاليف غير المباشرة
+        self.assertIn("indirect_costs", results)
+        self.assertIn("total_indirect_costs", results["indirect_costs"])
+        
+        # التحقق من وجود تكاليف المخاطر
+        self.assertIn("risk_costs", results)
+        self.assertIn("total_risk_cost", results["risk_costs"])
+        
+        # التحقق من وجود ملخص التسعير
+        self.assertIn("summary", results)
+        self.assertIn("final_price", results["summary"])
+
+
+class TestRiskAnalyzer(unittest.TestCase):
+    """اختبار محلل المخاطر"""
+    
+    def setUp(self):
+        """إعداد بيئة الاختبار"""
+        self.config = AppConfig()
+        self.risk_analyzer = RiskAnalyzer(self.config)
+    
+    def test_analyze_risks(self):
+        """اختبار تحليل المخاطر"""
+        # تحليل المخاطر
+        result = self.risk_analyzer.analyze_risks(1, "comprehensive")
+        self.assertTrue(result)
+        
+        # انتظار اكتمال التحليل
+        import time
+        max_wait = 5  # ثوانٍ
+        waited = 0
+        while self.risk_analyzer.analysis_in_progress and waited < max_wait:
+            time.sleep(0.5)
+            waited += 0.5
+        
+        # التحقق من نتائج التحليل
+        self.assertFalse(self.risk_analyzer.analysis_in_progress)
+        results = self.risk_analyzer.get_analysis_results()
+        self.assertEqual(results["status"], "اكتمل التحليل")
+        self.assertEqual(results["project_id"], 1)
+        self.assertEqual(results["method"], "comprehensive")
+        
+        # التحقق من وجود المخاطر المحددة
+        self.assertIn("identified_risks", results)
+        self.assertTrue(len(results["identified_risks"]) > 0)
+        
+        # التحقق من وجود فئات المخاطر
+        self.assertIn("risk_categories", results)
+        
+        # التحقق من وجود مصفوفة المخاطر
+        self.assertIn("risk_matrix", results)
+        
+        # التحقق من وجود استراتيجيات التخفيف
+        self.assertIn("mitigation_strategies", results)
+        self.assertTrue(len(results["mitigation_strategies"]) > 0)
+        
+        # التحقق من وجود ملخص التحليل
+        self.assertIn("summary", results)
+        self.assertIn("overall_risk_level", results["summary"])
+
+
+class TestAIAssistant(unittest.TestCase):
+    """اختبار المساعد الذكي"""
+    
+    def setUp(self):
+        """إعداد بيئة الاختبار"""
+        self.config = AppConfig()
+        self.assistant = AIAssistant(self.config)
+    
+    def test_process_query(self):
+        """اختبار معالجة الاستعلام"""
+        # معالجة استعلام
+        query = "كيف يمكنني تحليل مستند مناقصة؟"
+        result = self.assistant.process_query(query)
+        self.assertTrue(result)
+        
+        # انتظار اكتمال المعالجة
+        import time
+        max_wait = 5  # ثوانٍ
+        waited = 0
+        while self.assistant.processing_in_progress and waited < max_wait:
+            time.sleep(0.5)
+            waited += 0.5
+        
+        # التحقق من نتائج المعالجة
+        self.assertFalse(self.assistant.processing_in_progress)
+        results = self.assistant.get_processing_results()
+        self.assertEqual(results["status"], "اكتملت المعالجة")
+        self.assertEqual(results["query"], query)
+        
+        # التحقق من وجود استجابة
+        self.assertIn("response", results)
+        self.assertTrue(len(results["response"]) > 0)
+        
+        # التحقق من وجود اقتراحات
+        self.assertIn("suggestions", results)
+        self.assertTrue(len(results["suggestions"]) > 0)
+    
+    def test_conversation_history(self):
+        """اختبار سجل المحادثة"""
+        # معالجة استعلام
+        query = "ما هي استراتيجيات التسعير المتاحة؟"
+        self.assistant.process_query(query)
+        
+        # انتظار اكتمال المعالجة
+        import time
+        max_wait = 5  # ثوانٍ
+        waited = 0
+        while self.assistant.processing_in_progress and waited < max_wait:
+            time.sleep(0.5)
+            waited += 0.5
+        
+        # التحقق من سجل المحادثة
+        history = self.assistant.get_conversation_history()
+        self.assertEqual(len(history), 2)  # استعلام المستخدم واستجابة المساعد
+        self.assertEqual(history[0]["role"], "user")
+        self.assertEqual(history[0]["content"], query)
+        self.assertEqual(history[1]["role"], "assistant")
+        
+        # مسح سجل المحادثة
+        self.assertTrue(self.assistant.clear_conversation_history())
+        history = self.assistant.get_conversation_history()
+        self.assertEqual(len(history), 0)
+
+
+class TestStyling(unittest.TestCase):
+    """اختبار وحدات التصميم"""
+    
+    def test_app_theme(self):
+        """اختبار نمط التطبيق"""
+        theme = AppTheme()
+        
+        # التحقق من الألوان
+        self.assertIsNotNone(theme.get_color("bg_color"))
+        self.assertIsNotNone(theme.get_color("fg_color"))
+        
+        # التحقق من الخطوط
+        self.assertIsNotNone(theme.get_font("body"))
+        self.assertIsNotNone(theme.get_font("title"))
+        
+        # التحقق من الأحجام
+        self.assertIsNotNone(theme.get_size("padding_medium"))
+        self.assertIsNotNone(theme.get_size("border_radius"))
+        
+        # تغيير النمط
+        self.assertTrue(theme.set_theme("dark"))
+        self.assertEqual(theme.current_theme, "dark")
+        
+        # تغيير اللغة
+        self.assertTrue(theme.set_language("en"))
+        self.assertEqual(theme.current_language, "en")
+    
+    def test_icon_generator(self):
+        """اختبار مولد الأيقونات"""
+        icon_generator = IconGenerator()
+        
+        # توليد الأيقونات الافتراضية
+        icon_generator.generate_default_icons()
+        
+        # التحقق من وجود مجلد الأيقونات
+        self.assertTrue(Path('assets/icons').exists())
+        
+        # التحقق من وجود بعض الأيقونات
+        self.assertTrue(Path('assets/icons/dashboard.png').exists())
+        self.assertTrue(Path('assets/icons/projects.png').exists())
+    
+    def test_chart_generator(self):
+        """اختبار مولد الرسوم البيانية"""
+        theme = AppTheme()
+        chart_generator = ChartGenerator(theme)
+        
+        # إنشاء بيانات للرسم البياني الشريطي
+        bar_data = {
+            'labels': ['الربع الأول', 'الربع الثاني', 'الربع الثالث', 'الربع الرابع'],
+            'values': [15000, 20000, 18000, 25000]
+        }
+        
+        # إنشاء رسم بياني شريطي
+        fig = chart_generator.create_bar_chart(
+            bar_data,
+            'الإيرادات الفصلية',
+            'الفصل',
+            'الإيرادات (ريال)'
+        )
+        
+        # التحقق من إنشاء الرسم البياني
+        self.assertIsNotNone(fig)
+        
+        # حفظ الرسم البياني
+        save_path = 'test_chart.png'
+        chart_generator.create_bar_chart(
+            bar_data,
+            'الإيرادات الفصلية',
+            'الفصل',
+            'الإيرادات (ريال)',
+            save_path=save_path
+        )
+        
+        # التحقق من وجود ملف الرسم البياني
+        self.assertTrue(Path(save_path).exists())
+        
+        # حذف ملف الرسم البياني
+        if Path(save_path).exists():
+            Path(save_path).unlink()
+
+
+def run_tests():
+    """تشغيل الاختبارات"""
+    # إنشاء مجلد الاختبارات
+    test_dir = Path('test_results')
+    test_dir.mkdir(exist_ok=True)
+    
+    # إنشاء ملف لنتائج الاختبارات
+    test_results_file = test_dir / 'test_results.txt'
+    
+    # تشغيل الاختبارات وحفظ النتائج
+    with open(test_results_file, 'w', encoding='utf-8') as f:
+        runner = unittest.TextTestRunner(stream=f, verbosity=2)
+        suite = unittest.TestSuite()
+        
+        # إضافة اختبارات قاعدة البيانات
+        suite.addTest(unittest.makeSuite(TestDatabaseConnector))
+        suite.addTest(unittest.makeSuite(TestModels))
+        
+        # إضافة اختبارات الوحدات
+        suite.addTest(unittest.makeSuite(TestDocumentAnalyzer))
+        suite.addTest(unittest.makeSuite(TestPricingEngine))
+        suite.addTest(unittest.makeSuite(TestRiskAnalyzer))
+        suite.addTest(unittest.makeSuite(TestAIAssistant))
+        
+        # إضافة اختبارات التصميم
+        suite.addTest(unittest.makeSuite(TestStyling))
+        
+        # تشغيل الاختبارات
+        result = runner.run(suite)
+        
+        # كتابة ملخص النتائج
+        f.write("\n\n=== ملخص نتائج الاختبارات ===\n")
+        f.write(f"عدد الاختبارات: {result.testsRun}\n")
+        f.write(f"عدد النجاحات: {result.testsRun - len(result.failures) - len(result.errors)}\n")
+        f.write(f"عدد الإخفاقات: {len(result.failures)}\n")
+        f.write(f"عدد الأخطاء: {len(result.errors)}\n")
+    
+    # طباعة ملخص النتائج
+    logger.info(f"تم تشغيل {result.testsRun} اختبار")
+    logger.info(f"النجاحات: {result.testsRun - len(result.failures) - len(result.errors)}")
+    logger.info(f"الإخفاقات: {len(result.failures)}")
+    logger.info(f"الأخطاء: {len(result.errors)}")
+    logger.info(f"تم حفظ نتائج الاختبارات في: {test_results_file}")
+    
+    return result
+
+
+if __name__ == "__main__":
+    run_tests()

tests/test_integrated_system.py

@@ -0,0 +1,96 @@
+"""
+وحدة اختبار النظام المتكامل
+"""
+
+import unittest
+import os
+import sys
+from pathlib import Path
+
+# إضافة المسار الرئيسي للنظام
+sys.path.append(str(Path(__file__).parent.parent))
+
+# استيراد الوحدات
+from modules.pricing.pricing_app import PricingApp
+from modules.ai_assistant.ai_app import AIAssistantApp
+from modules.document_analysis.document_app import DocumentAnalysisApp
+from modules.data_analysis.data_analysis_app import DataAnalysisApp
+from modules.resources.resources_app import ResourcesApp
+
+class TestIntegratedSystem(unittest.TestCase):
+    """اختبارات النظام المتكامل"""
+    
+    def setUp(self):
+        """إعداد بيئة الاختبار"""
+        # التأكد من وجود جميع الملفات الرئيسية
+        self.main_files = [
+            "app.py",
+            "config.py",
+            "requirements.txt"
+        ]
+        
+        # التأكد من وجود جميع المجلدات الرئيسية
+        self.main_directories = [
+            "modules",
+            "assets",
+            "data",
+            "utils"
+        ]
+        
+        # التأكد من وجود جميع وحدات النظام
+        self.modules = [
+            "modules/pricing",
+            "modules/ai_assistant",
+            "modules/document_analysis",
+            "modules/data_analysis",
+            "modules/resources",
+            "modules/project_management",
+            "modules/reports",
+            "modules/risk_analysis"
+        ]
+    
+    def test_main_files_exist(self):
+        """اختبار وجود الملفات الرئيسية"""
+        for file in self.main_files:
+            file_path = Path(__file__).parent.parent / file
+            self.assertTrue(file_path.exists(), f"الملف {file} غير موجود")
+    
+    def test_main_directories_exist(self):
+        """اختبار وجود المجلدات الرئيسية"""
+        for directory in self.main_directories:
+            dir_path = Path(__file__).parent.parent / directory
+            self.assertTrue(dir_path.exists(), f"المجلد {directory} غير موجود")
+    
+    def test_modules_exist(self):
+        """اختبار وجود وحدات النظام"""
+        for module in self.modules:
+            module_path = Path(__file__).parent.parent / module
+            self.assertTrue(module_path.exists(), f"الوحدة {module} غير موجودة")
+    
+    def test_pricing_module(self):
+        """اختبار وحدة التسعير"""
+        pricing_app = PricingApp()
+        self.assertIsNotNone(pricing_app, "فشل إنشاء وحدة التسعير")
+    
+    def test_ai_assistant_module(self):
+        """اختبار وحدة الذكاء الاصطناعي"""
+        ai_app = AIAssistantApp()
+        self.assertIsNotNone(ai_app, "فشل إنشاء وحدة الذكاء الاصطناعي")
+    
+    def test_document_analysis_module(self):
+        """اختبار وحدة تحليل المستندات"""
+        document_app = DocumentAnalysisApp()
+        self.assertIsNotNone(document_app, "فشل إنشاء وحدة تحليل المستندات")
+    
+    def test_data_analysis_module(self):
+        """اختبار وحدة تحليل البيانات"""
+        data_analysis_app = DataAnalysisApp()
+        self.assertIsNotNone(data_analysis_app, "فشل إنشاء وحدة تحليل البيانات")
+    
+    def test_resources_module(self):
+        """اختبار وحدة الموارد"""
+        resources_app = ResourcesApp()
+        self.assertIsNotNone(resources_app, "فشل إنشاء وحدة الموارد")
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_modules.py

@@ -0,0 +1,244 @@
+"""
+اختبارات وحدات نظام المناقصات
+
+هذا الملف يحتوي على اختبارات للتحقق من عمل وحدات نظام المناقصات بشكل صحيح.
+"""
+
+import os
+import sys
+import unittest
+from unittest.mock import patch, MagicMock
+import pandas as pd
+import numpy as np
+
+# إضافة مسار المشروع إلى مسار النظام
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+# محاكاة Streamlit
+class StreamlitMock:
+    def __init__(self):
+        self.session_state = {"theme": "light"}
+        self.sidebar_items = []
+        self.page_items = []
+    
+    def title(self, text):
+        self.page_items.append(f"TITLE: {text}")
+        return None
+    
+    def header(self, text):
+        self.page_items.append(f"HEADER: {text}")
+        return None
+    
+    def subheader(self, text):
+        self.page_items.append(f"SUBHEADER: {text}")
+        return None
+    
+    def write(self, text):
+        self.page_items.append(f"WRITE: {text}")
+        return None
+    
+    def sidebar(self):
+        return self
+    
+    def selectbox(self, label, options, index=0):
+        self.page_items.append(f"SELECTBOX: {label}, OPTIONS: {options}")
+        return options[index] if options else None
+    
+    def radio(self, label, options, index=0):
+        self.page_items.append(f"RADIO: {label}, OPTIONS: {options}")
+        return options[index] if options else None
+    
+    def checkbox(self, label, value=False):
+        self.page_items.append(f"CHECKBOX: {label}, VALUE: {value}")
+        return value
+    
+    def button(self, label):
+        self.page_items.append(f"BUTTON: {label}")
+        return False
+    
+    def file_uploader(self, label, type=None, accept_multiple_files=False):
+        self.page_items.append(f"FILE_UPLOADER: {label}, TYPE: {type}")
+        return None
+    
+    def columns(self, spec):
+        cols = [StreamlitMock() for _ in range(len(spec))]
+        self.page_items.append(f"COLUMNS: {spec}")
+        return cols
+    
+    def tabs(self, tabs):
+        tab_objects = [StreamlitMock() for _ in tabs]
+        self.page_items.append(f"TABS: {tabs}")
+        return tab_objects
+    
+    def expander(self, label):
+        exp = StreamlitMock()
+        self.page_items.append(f"EXPANDER: {label}")
+        return exp
+    
+    def __enter__(self):
+        return self
+        
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+    
+    def success(self, text):
+        self.page_items.append(f"SUCCESS: {text}")
+        return None
+    
+    def error(self, text):
+        self.page_items.append(f"ERROR: {text}")
+        return None
+    
+    def warning(self, text):
+        self.page_items.append(f"WARNING: {text}")
+        return None
+    
+    def info(self, text):
+        self.page_items.append(f"INFO: {text}")
+        return None
+    
+    def markdown(self, text):
+        self.page_items.append(f"MARKDOWN: {text}")
+        return None
+    
+    def metric(self, label, value, delta=None):
+        self.page_items.append(f"METRIC: {label}, VALUE: {value}, DELTA: {delta}")
+        return None
+    
+    def progress(self, value):
+        self.page_items.append(f"PROGRESS: {value}")
+        return None
+    
+    def json(self, data):
+        self.page_items.append(f"JSON: {data}")
+        return None
+    
+    def dataframe(self, data):
+        self.page_items.append(f"DATAFRAME: {type(data)}")
+        return None
+    
+    def line_chart(self, data):
+        self.page_items.append(f"LINE_CHART: {type(data)}")
+        return None
+    
+    def bar_chart(self, data):
+        self.page_items.append(f"BAR_CHART: {type(data)}")
+        return None
+    
+    def pyplot(self, fig):
+        self.page_items.append(f"PYPLOT: {type(fig)}")
+        return None
+    
+    def download_button(self, label, data, file_name, mime=None):
+        self.page_items.append(f"DOWNLOAD_BUTTON: {label}, FILE_NAME: {file_name}")
+        return False
+    
+    def form(self, key):
+        form = StreamlitMock()
+        self.page_items.append(f"FORM: {key}")
+        return form
+    
+    def form_submit_button(self, label):
+        self.page_items.append(f"FORM_SUBMIT_BUTTON: {label}")
+        return False
+    
+    def rerun(self):
+        self.page_items.append("RERUN")
+        return None
+
+# تعريف الاختبارات
+class TestContractAnalyzer(unittest.TestCase):
+    """اختبارات محلل العقود"""
+    
+    def test_contract_analyzer_initialization(self):
+        """اختبار تهيئة محلل العقود"""
+        from modules.ai_assistant.contract_analyzer import ContractAnalyzer
+        
+        # تهيئة المحلل
+        analyzer = ContractAnalyzer()
+        
+        # التحقق من تهيئة الخصائص
+        self.assertEqual(analyzer.api_key_source, "security_section")
+        self.assertIsNotNone(analyzer.openai_api_key)
+        self.assertIsNotNone(analyzer.claude_api_key)
+        self.assertTrue(analyzer.hybrid_environment)
+    
+    def test_contract_analysis(self):
+        """اختبار تحليل العقود"""
+        from modules.ai_assistant.contract_analyzer import ContractAnalyzer
+        
+        # تهيئة المحلل
+        analyzer = ContractAnalyzer()
+        
+        # إنشاء ملف عقد وهمي
+        contract_file = "/tmp/test_contract.txt"
+        with open(contract_file, "w") as f:
+            f.write("عقد إنشاء مبنى إداري")
+        
+        # تحليل العقد
+        result = analyzer.analyze_contract(contract_file)
+        
+        # التحقق من النتائج
+        self.assertIsNotNone(result)
+        self.assertIn("title", result)
+        self.assertIn("summary", result)
+        self.assertIn("key_points", result)
+        self.assertIn("entities", result)
+        
+        # حذف الملف الوهمي
+        os.remove(contract_file)
+    
+    def test_tender_analysis(self):
+        """اختبار تحليل المناقصات"""
+        from modules.ai_assistant.contract_analyzer import ContractAnalyzer
+        
+        # تهيئة المحلل
+        analyzer = ContractAnalyzer()
+        
+        # إنشاء ملف مناقصة وهمي
+        tender_file = "/tmp/test_tender.txt"
+        with open(tender_file, "w") as f:
+            f.write("مناقصة إنشاء مبنى إداري")
+        
+        # تحليل المناقصة
+        result = analyzer.analyze_tender(tender_file)
+        
+        # التحقق من النتائج
+        self.assertIsNotNone(result)
+        self.assertIn("title", result)
+        self.assertIn("summary", result)
+        self.assertIn("key_points", result)
+        self.assertIn("entities", result)
+        
+        # حذف الملف الوهمي
+        os.remove(tender_file)
+    
+    def test_dwg_analysis(self):
+        """اختبار تحليل ملفات DWG"""
+        from modules.ai_assistant.contract_analyzer import ContractAnalyzer
+        
+        # تهيئة المحلل
+        analyzer = ContractAnalyzer()
+        
+        # إنشاء ملف DWG وهمي
+        dwg_file = "/tmp/test_drawing.dwg"
+        with open(dwg_file, "w") as f:
+            f.write("DWG FILE CONTENT")
+        
+        # تحليل ملف DWG
+        result = analyzer.analyze_dwg_file(dwg_file)
+        
+        # التحقق من النتائج
+        self.assertIsNotNone(result)
+        self.assertIn("file_name", result)
+        self.assertIn("elements_count", result)
+        self.assertIn("dimensions", result)
+        self.assertIn("materials", result)
+        self.assertIn("cost_estimate", result)
+        
+        # حذف الملف الوهمي
+        os.remove(dwg_file)
+
+# تشغيل الاختبارات
+if __name__ == '__main__':
+    unittest.main()

tests/test_ui.py

@@ -0,0 +1,413 @@
+"""
+وحدة اختبار واجهة المستخدم لنظام إدارة المناقصات - Hybrid Face
+"""
+
+import os
+import sys
+import logging
+import unittest
+import tkinter as tk
+import customtkinter as ctk
+from pathlib import Path
+
+# تهيئة السجل
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger('test_ui')
+
+# إضافة المسار الرئيسي للتطبيق إلى مسار البحث
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# استيراد الوحدات المطلوبة للاختبار
+from styling.theme import AppTheme
+from styling.icons import IconGenerator
+from styling.charts import ChartGenerator
+from config import AppConfig
+
+class TestUIComponents(unittest.TestCase):
+    """اختبار مكونات واجهة المستخدم"""
+    
+    def setUp(self):
+        """إعداد بيئة الاختبار"""
+        self.root = ctk.CTk()
+        self.root.withdraw()  # إخفاء النافذة أثناء الاختبار
+        self.theme = AppTheme()
+    
+    def tearDown(self):
+        """تنظيف بيئة الاختبار"""
+        self.root.destroy()
+    
+    def test_styled_frame(self):
+        """اختبار الإطار المنسق"""
+        frame = self.theme.create_styled_frame(self.root)
+        self.assertIsNotNone(frame)
+        self.assertEqual(frame.cget("fg_color"), self.theme.get_color("card_bg_color"))
+        self.assertEqual(frame.cget("corner_radius"), self.theme.get_size("border_radius"))
+    
+    def test_styled_button(self):
+        """اختبار الزر المنسق"""
+        button = self.theme.create_styled_button(self.root, "زر اختبار")
+        self.assertIsNotNone(button)
+        self.assertEqual(button.cget("text"), "زر اختبار")
+        self.assertEqual(button.cget("fg_color"), self.theme.get_color("button_bg_color"))
+        self.assertEqual(button.cget("text_color"), self.theme.get_color("button_fg_color"))
+    
+    def test_styled_label(self):
+        """اختبار التسمية المنسقة"""
+        label = self.theme.create_styled_label(self.root, "تسمية اختبار")
+        self.assertIsNotNone(label)
+        self.assertEqual(label.cget("text"), "تسمية اختبار")
+        self.assertEqual(label.cget("text_color"), self.theme.get_color("fg_color"))
+    
+    def test_styled_entry(self):
+        """اختبار حقل الإدخال المنسق"""
+        entry = self.theme.create_styled_entry(self.root, "نص توضيحي")
+        self.assertIsNotNone(entry)
+        self.assertEqual(entry.cget("placeholder_text"), "نص توضيحي")
+        self.assertEqual(entry.cget("fg_color"), self.theme.get_color("input_bg_color"))
+        self.assertEqual(entry.cget("text_color"), self.theme.get_color("input_fg_color"))
+    
+    def test_styled_combobox(self):
+        """اختبار القائمة المنسدلة المنسقة"""
+        values = ["الخيار الأول", "الخيار الثاني", "الخيار الثالث"]
+        combobox = self.theme.create_styled_combobox(self.root, values)
+        self.assertIsNotNone(combobox)
+        self.assertEqual(combobox.cget("values"), values)
+        self.assertEqual(combobox.cget("fg_color"), self.theme.get_color("input_bg_color"))
+        self.assertEqual(combobox.cget("text_color"), self.theme.get_color("input_fg_color"))
+    
+    def test_styled_checkbox(self):
+        """اختبار خانة الاختيار المنسقة"""
+        checkbox = self.theme.create_styled_checkbox(self.root, "خانة اختبار")
+        self.assertIsNotNone(checkbox)
+        self.assertEqual(checkbox.cget("text"), "خانة اختبار")
+        self.assertEqual(checkbox.cget("fg_color"), self.theme.get_color("button_bg_color"))
+        self.assertEqual(checkbox.cget("text_color"), self.theme.get_color("fg_color"))
+    
+    def test_styled_radio_button(self):
+        """اختبار زر الراديو المنسق"""
+        var = ctk.StringVar(value="1")
+        radio_button = self.theme.create_styled_radio_button(self.root, "زر راديو اختبار", var, "1")
+        self.assertIsNotNone(radio_button)
+        self.assertEqual(radio_button.cget("text"), "زر راديو اختبار")
+        self.assertEqual(radio_button.cget("fg_color"), self.theme.get_color("button_bg_color"))
+        self.assertEqual(radio_button.cget("text_color"), self.theme.get_color("fg_color"))
+    
+    def test_styled_switch(self):
+        """اختبار مفتاح التبديل المنسق"""
+        switch = self.theme.create_styled_switch(self.root, "مفتاح اختبار")
+        self.assertIsNotNone(switch)
+        self.assertEqual(switch.cget("text"), "مفتاح اختبار")
+        self.assertEqual(switch.cget("progress_color"), self.theme.get_color("button_bg_color"))
+        self.assertEqual(switch.cget("text_color"), self.theme.get_color("fg_color"))
+    
+    def test_styled_slider(self):
+        """اختبار شريط التمرير المنسق"""
+        slider = self.theme.create_styled_slider(self.root)
+        self.assertIsNotNone(slider)
+        self.assertEqual(slider.cget("fg_color"), self.theme.get_color("input_border_color"))
+        self.assertEqual(slider.cget("progress_color"), self.theme.get_color("button_bg_color"))
+    
+    def test_styled_progressbar(self):
+        """اختبار شريط التقدم المنسق"""
+        progressbar = self.theme.create_styled_progressbar(self.root)
+        self.assertIsNotNone(progressbar)
+        self.assertEqual(progressbar.cget("fg_color"), self.theme.get_color("input_border_color"))
+        self.assertEqual(progressbar.cget("progress_color"), self.theme.get_color("button_bg_color"))
+    
+    def test_styled_tabview(self):
+        """اختبار عرض التبويب المنسق"""
+        tabview = self.theme.create_styled_tabview(self.root)
+        self.assertIsNotNone(tabview)
+        self.assertEqual(tabview.cget("fg_color"), self.theme.get_color("card_bg_color"))
+    
+    def test_styled_scrollable_frame(self):
+        """اختبار الإطار القابل للتمرير المنسق"""
+        scrollable_frame = self.theme.create_styled_scrollable_frame(self.root)
+        self.assertIsNotNone(scrollable_frame)
+        self.assertEqual(scrollable_frame.cget("fg_color"), "transparent")
+    
+    def test_styled_textbox(self):
+        """اختبار مربع النص المنسق"""
+        textbox = self.theme.create_styled_textbox(self.root)
+        self.assertIsNotNone(textbox)
+        self.assertEqual(textbox.cget("fg_color"), self.theme.get_color("input_bg_color"))
+        self.assertEqual(textbox.cget("text_color"), self.theme.get_color("input_fg_color"))
+    
+    def test_styled_card(self):
+        """اختبار البطاقة المنسقة"""
+        card, content_frame = self.theme.create_styled_card(self.root, "بطاقة اختبار")
+        self.assertIsNotNone(card)
+        self.assertIsNotNone(content_frame)
+        self.assertEqual(card.cget("fg_color"), self.theme.get_color("card_bg_color"))
+    
+    def test_styled_data_table(self):
+        """اختبار جدول البيانات المنسق"""
+        columns = ["العمود الأول", "العمود الثاني", "العمود الثالث"]
+        data = [
+            ["بيانات 1-1", "بيانات 1-2", "بيانات 1-3"],
+            ["بيانات 2-1", "بيانات 2-2", "بيانات 2-3"]
+        ]
+        table_frame, data_frame = self.theme.create_styled_data_table(self.root, columns, data)
+        self.assertIsNotNone(table_frame)
+        self.assertIsNotNone(data_frame)
+        self.assertEqual(table_frame.cget("fg_color"), self.theme.get_color("card_bg_color"))
+    
+    def test_theme_switching(self):
+        """اختبار تبديل النمط"""
+        # تعيين النمط الفاتح
+        self.theme.set_theme("light")
+        light_bg_color = self.theme.get_color("bg_color")
+        
+        # تعيين النمط الداكن
+        self.theme.set_theme("dark")
+        dark_bg_color = self.theme.get_color("bg_color")
+        
+        # التحقق من اختلاف الألوان
+        self.assertNotEqual(light_bg_color, dark_bg_color)
+    
+    def test_language_switching(self):
+        """اختبار تبديل اللغة"""
+        # تعيين اللغة العربية
+        self.theme.set_language("ar")
+        ar_font = self.theme.get_font("body")
+        
+        # تعيين اللغة الإنجليزية
+        self.theme.set_language("en")
+        en_font = self.theme.get_font("body")
+        
+        # التحقق من اختلاف الخطوط
+        self.assertNotEqual(ar_font[0], en_font[0])
+
+
+class TestUILayout(unittest.TestCase):
+    """اختبار تخطيط واجهة المستخدم"""
+    
+    def setUp(self):
+        """إعداد بيئة الاختبار"""
+        self.root = ctk.CTk()
+        self.root.withdraw()  # إخفاء النافذة أثناء الاختبار
+        self.theme = AppTheme()
+        
+        # إنشاء الإطار الرئيسي
+        self.main_frame = self.theme.create_styled_frame(self.root)
+        self.main_frame.pack(fill="both", expand=True)
+        
+        # إنشاء الشريط الجانبي
+        self.sidebar_frame = self.theme.create_styled_frame(
+            self.main_frame,
+            fg_color=self.theme.get_color("sidebar_bg_color")
+        )
+        self.sidebar_frame.pack(side="left", fill="y", padx=0, pady=0)
+        
+        # إنشاء إطار المحتوى
+        self.content_frame = self.theme.create_styled_frame(
+            self.main_frame,
+            fg_color=self.theme.get_color("bg_color")
+        )
+        self.content_frame.pack(side="right", fill="both", expand=True, padx=0, pady=0)
+    
+    def tearDown(self):
+        """تنظيف بيئة الاخ��بار"""
+        self.root.destroy()
+    
+    def test_sidebar_layout(self):
+        """اختبار تخطيط الشريط الجانبي"""
+        # إنشاء شعار التطبيق
+        logo_label = self.theme.create_styled_label(
+            self.sidebar_frame,
+            "نظام إدارة المناقصات",
+            font=self.theme.get_font("title"),
+            text_color=self.theme.get_color("sidebar_fg_color")
+        )
+        logo_label.pack(padx=20, pady=20)
+        
+        # إنشاء أزرار الشريط الجانبي
+        sidebar_buttons = []
+        button_texts = [
+            "لوحة التحكم", "المشاريع", "المستندات", "التسعير",
+            "الموارد", "المخاطر", "التقارير", "الذكاء الاصطناعي"
+        ]
+        
+        for text in button_texts:
+            button_frame, button = self.theme.create_styled_sidebar_button(
+                self.sidebar_frame,
+                text
+            )
+            button_frame.pack(fill="x", padx=0, pady=2)
+            sidebar_buttons.append(button)
+        
+        # التحقق من إنشاء الأزرار
+        self.assertEqual(len(sidebar_buttons), len(button_texts))
+        for i, button in enumerate(sidebar_buttons):
+            self.assertEqual(button.cget("text"), button_texts[i])
+    
+    def test_content_layout(self):
+        """اختبار تخطيط المحتوى"""
+        # إنشاء شريط العنوان
+        header_frame = self.theme.create_styled_frame(
+            self.content_frame,
+            fg_color=self.theme.get_color("card_bg_color")
+        )
+        header_frame.pack(fill="x", padx=20, pady=20)
+        
+        # إنشاء عنوان الصفحة
+        page_title = self.theme.create_styled_label(
+            header_frame,
+            "لوحة التحكم",
+            font=self.theme.get_font("title")
+        )
+        page_title.pack(side="left", padx=20, pady=20)
+        
+        # إنشاء زر البحث
+        search_button = self.theme.create_styled_button(
+            header_frame,
+            "بحث"
+        )
+        search_button.pack(side="right", padx=20, pady=20)
+        
+        # إنشاء إطار البطاقات
+        cards_frame = self.theme.create_styled_frame(
+            self.content_frame,
+            fg_color="transparent"
+        )
+        cards_frame.pack(fill="both", expand=True, padx=20, pady=20)
+        
+        # إنشاء بطاقات
+        cards = []
+        card_titles = [
+            "المشاريع النشطة", "المناقصات الجديدة", "المخاطر العالية", "التقارير المعلقة"
+        ]
+        
+        for i, title in enumerate(card_titles):
+            card, card_content = self.theme.create_styled_card(
+                cards_frame,
+                title
+            )
+            card.grid(row=i//2, column=i%2, padx=10, pady=10, sticky="nsew")
+            cards.append(card)
+        
+        # التحقق من إنشاء البطاقات
+        self.assertEqual(len(cards), len(card_titles))
+        
+        # تهيئة أوزان الصفوف والأعمدة
+        cards_frame.grid_columnconfigure(0, weight=1)
+        cards_frame.grid_columnconfigure(1, weight=1)
+        cards_frame.grid_rowconfigure(0, weight=1)
+        cards_frame.grid_rowconfigure(1, weight=1)
+    
+    def test_responsive_layout(self):
+        """اختبار التخطيط المتجاوب"""
+        # تغيير حجم النافذة
+        self.root.geometry("800x600")
+        self.root.update()
+        
+        # التحقق من أن الإطار الرئيسي يملأ النافذة
+        self.assertEqual(self.main_frame.winfo_width(), 800)
+        self.assertEqual(self.main_frame.winfo_height(), 600)
+        
+        # تغيير حجم النافذة مرة أخرى
+        self.root.geometry("1024x768")
+        self.root.update()
+        
+        # التحقق من أن الإطار الرئيسي يملأ النافذة
+        self.assertEqual(self.main_frame.winfo_width(), 1024)
+        self.assertEqual(self.main_frame.winfo_height(), 768)
+
+
+class TestUIArabicSupport(unittest.TestCase):
+    """اختبار دعم اللغة العربية في واجهة المستخدم"""
+    
+    def setUp(self):
+        """إعداد بيئة الاختبار"""
+        self.root = ctk.CTk()
+        self.root.withdraw()  # إخفاء النافذة أثناء الاختبار
+        self.theme = AppTheme()
+        self.theme.set_language("ar")  # تعيين اللغة العربية
+    
+    def tearDown(self):
+        """تنظيف بيئة الاختبار"""
+        self.root.destroy()
+    
+    def test_arabic_text_display(self):
+        """اختبار عرض النص العربي"""
+        # إنشاء تسمية بنص عربي
+        arabic_text = "هذا نص عربي للاختبار"
+        label = self.theme.create_styled_label(self.root, arabic_text)
+        self.assertEqual(label.cget("text"), arabic_text)
+        
+        # إنشاء زر بنص عربي
+        button = self.theme.create_styled_button(self.root, "زر باللغة العربية")
+        self.assertEqual(button.cget("text"), "زر باللغة العربية")
+        
+        # إنشاء حقل إدخال بنص توضيحي عربي
+        entry = self.theme.create_styled_entry(self.root, "أدخل النص هنا")
+        self.assertEqual(entry.cget("placeholder_text"), "أدخل النص هنا")
+    
+    def test_arabic_font(self):
+        """اختبار الخط العربي"""
+        # التحقق من استخدام خط يدعم العربية
+        ar_font = self.theme.get_font("body")
+        self.assertEqual(ar_font[0], "Cairo")
+    
+    def test_rtl_support(self):
+        """اختبار دعم الكتابة من اليمين إلى اليسار"""
+        # إنشاء إطار
+        frame = self.theme.create_styled_frame(self.root)
+        frame.pack(fill="both", expand=True)
+        
+        # إنشاء تسمية بنص عربي
+        label = self.theme.create_styled_label(frame, "نص عربي من اليمين إلى اليسار")
+        label.pack(anchor="e", padx=20, pady=20)  # محاذاة إلى اليمين
+        
+        # التحقق من المحاذاة
+        self.assertEqual(label.cget("anchor"), "w")  # w تعني غرب (يسار)، لكن النص سيظهر من اليمين إلى اليسار
+
+
+def run_ui_tests():
+    """تشغيل اختبارات واجهة المستخدم"""
+    # إنشاء مجلد الاختبارات
+    test_dir = Path('test_results')
+    test_dir.mkdir(exist_ok=True)
+    
+    # إنشاء ملف لنتائج الاختبارات
+    test_results_file = test_dir / 'ui_test_results.txt'
+    
+    # تشغيل الاختبارات وحفظ النتائج
+    with open(test_results_file, 'w', encoding='utf-8') as f:
+        runner = unittest.TextTestRunner(stream=f, verbosity=2)
+        suite = unittest.TestSuite()
+        
+        # إضافة اختبارات مكونات واجهة المستخدم
+        suite.addTest(unittest.makeSuite(TestUIComponents))
+        
+        # إضافة اختبارات تخطيط واجهة المستخدم
+        suite.addTest(unittest.makeSuite(TestUILayout))
+        
+        # إضافة اختبارات دعم اللغة العربية
+        suite.addTest(unittest.makeSuite(TestUIArabicSupport))
+        
+        # تشغيل الاختبارات
+        result = runner.run(suite)
+        
+        # كتابة ملخص النتائج
+        f.write("\n\n=== ملخص نتائج اختبارات واجهة المستخدم ===\n")
+        f.write(f"عدد الاختبارات: {result.testsRun}\n")
+        f.write(f"عدد النجاحات: {result.testsRun - len(result.failures) - len(result.errors)}\n")
+        f.write(f"عدد الإخفاقات: {len(result.failures)}\n")
+        f.write(f"عدد الأخطاء: {len(result.errors)}\n")
+    
+    # طباعة ملخص النتائج
+    logger.info(f"تم تشغيل {result.testsRun} اختبار لواجهة المستخدم")
+    logger.info(f"النجاحات: {result.testsRun - len(result.failures) - len(result.errors)}")
+    logger.info(f"الإخفاقات: {len(result.failures)}")
+    logger.info(f"الأخطاء: {len(result.errors)}")
+    logger.info(f"تم حفظ نتائج الاختبارات في: {test_results_file}")
+    
+    return result
+
+
+if __name__ == "__main__":
+    run_ui_tests()