Update modules/data_analysis/data_analysis_app.py

modules/data_analysis/data_analysis_app.py

@@ -1,525 +1,497 @@
-"""
-وحدة تكامل البيانات مع الذكاء الاصطناعي
-
-هذا الملف يحتوي على الفئات والدوال اللازمة لتكامل وحدة تحليل البيانات مع وحدة الذكاء الاصطناعي.
-"""
-
+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 seaborn as sns
 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:
-    """فئة تكامل البيانات مع الذكاء الاصطناعي"""
+class DataAnalysisApp:
+    """تطبيق تحليل البيانات"""
     
     def __init__(self):
-        """تهيئة فئة تكامل البيانات مع الذكاء الاصطناعي"""
-        self.data_analysis_app = DataAnalysisApp()
+        """تهيئة تطبيق تحليل البيانات"""
+        self.data = None
+        self.file_path = None
     
-    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)
-        }
+    def run(self):
+        """تشغيل تطبيق تحليل البيانات"""
+        # استيراد مدير التكوين
+        from config_manager import ConfigManager
         
-        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)
-        }
+        # محاولة تعيين تكوين الصفحة (سيتم تجاهلها إذا كان التكوين معينًا بالفعل)
+        config_manager = ConfigManager()
+        config_manager.set_page_config_if_needed(
+            page_title="تحليل البيانات",
+            page_icon="📊",
+            layout="wide"
+        )
         
-        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)
-        }
+        # عرض عنوان التطبيق
+        st.title("تحليل البيانات")
+        st.write("استخدم هذه الأداة لتحليل بيانات المناقصات والمشاريع")
         
-        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
-            })
+        # إنشاء علامات تبويب للتطبيق
+        tabs = st.tabs(["تحميل البيانات", "استكشاف البيانات", "تحليل متقدم", "التصور المرئي", "التقارير"])
         
-        # إعداد النتائج
-        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)
-        }
+        with tabs[0]:
+            self._load_data_tab()
         
-        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': [
-                'يمكن تقليل تكلفة المواد باستخدام بدائل أقل تكلفة',
-                'يمكن تحسين كفاءة استخدام المساحة',
-                'يمكن تقليل عدد الأعمدة لتوفير التكلفة',
-                'يمكن تحسين تصميم السلالم لزيادة السلامة',
-                'يمكن تحسين توزيع النوافذ لزيادة الإضاءة الطبيعية'
-            ]
-        }
+        with tabs[1]:
+            self._explore_data_tab()
         
-        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
+        with tabs[2]:
+            self._advanced_analysis_tab()
+        
+        with tabs[3]:
+            self._visualization_tab()
+        
+        with tabs[4]:
+            self._reports_tab()
     
-    # دوال مساعدة داخلية
+    def _load_data_tab(self):
+        """علامة تبويب تحميل البيانات"""
+        st.header("تحميل البيانات")
+        
+        # خيارات تحميل البيانات
+        data_source = st.radio(
+            "اختر مصدر البيانات:",
+            ["تحميل ملف", "استيراد من قاعدة البيانات", "استخدام بيانات نموذجية"]
+        )
+        
+        if data_source == "تحميل ملف":
+            uploaded_file = st.file_uploader("اختر ملف CSV أو Excel", type=["csv", "xlsx", "xls"])
+            
+            if uploaded_file is not None:
+                try:
+                    if uploaded_file.name.endswith('.csv'):
+                        self.data = pd.read_csv(uploaded_file)
+                    else:
+                        self.data = pd.read_excel(uploaded_file)
+                    
+                    st.success(f"تم تحميل الملف بنجاح! عدد الصفوف: {self.data.shape[0]}, عدد الأعمدة: {self.data.shape[1]}")
+                    st.write("معاينة البيانات:")
+                    st.dataframe(self.data.head())
+                except Exception as e:
+                    st.error(f"حدث خطأ أثناء تحميل الملف: {str(e)}")
+        
+        elif data_source == "استيراد من قاعدة البيانات":
+            st.info("هذه الميزة قيد التطوير")
+            
+            # محاكاة الاتصال بقاعدة البيانات
+            if st.button("اتصال بقاعدة البيانات"):
+                with st.spinner("جاري الاتصال بقاعدة البيانات..."):
+                    # محاكاة تأخير الاتصال
+                    import time
+                    time.sleep(2)
+                    
+                    # إنشاء بيانات نموذجية
+                    self.data = self._create_sample_data()
+                    
+                    st.success("تم الاتصال بقاعدة البيانات بنجاح!")
+                    st.write("معاينة البيانات:")
+                    st.dataframe(self.data.head())
+        
+        elif data_source == "استخدام بيانات نموذجية":
+            if st.button("تحميل بيانات نموذجية"):
+                self.data = self._create_sample_data()
+                st.success("تم تحميل البيانات النموذجية بنجاح!")
+                st.write("معاينة البيانات:")
+                st.dataframe(self.data.head())
     
-    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
-        }
+    def _explore_data_tab(self):
+        """علامة تبويب استكشاف البيانات"""
+        st.header("استكشاف البيانات")
         
-        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
-        }
+        if self.data is None:
+            st.info("الرجاء تحميل البيانات أولاً من علامة تبويب 'تحميل البيانات'")
+            return
+        
+        # عرض معلومات عامة عن البيانات
+        st.subheader("معلومات عامة")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.write(f"عدد الصفوف: {self.data.shape[0]}")
+            st.write(f"عدد الأعمدة: {self.data.shape[1]}")
+            st.write(f"القيم المفقودة: {self.data.isna().sum().sum()}")
+        
+        with col2:
+            st.write(f"أنواع البيانات:")
+            st.write(self.data.dtypes)
+        
+        # عرض إحصاءات وصفية
+        st.subheader("إحصاءات وصفية")
+        st.dataframe(self.data.describe())
         
-        return pd.DataFrame(competitors_data)
+        # عرض معلومات عن الأعمدة
+        st.subheader("معلومات الأعمدة")
+        
+        selected_column = st.selectbox("اختر عمودًا لتحليله:", self.data.columns)
+        
+        if selected_column:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.write(f"نوع البيانات: {self.data[selected_column].dtype}")
+                st.write(f"القيم الفريدة: {self.data[selected_column].nunique()}")
+                st.write(f"القيم المفقودة: {self.data[selected_column].isna().sum()}")
+            
+            with col2:
+                if pd.api.types.is_numeric_dtype(self.data[selected_column]):
+                    st.write(f"الحد الأدنى: {self.data[selected_column].min()}")
+                    st.write(f"الحد الأقصى: {self.data[selected_column].max()}")
+                    st.write(f"المتوسط: {self.data[selected_column].mean()}")
+                    st.write(f"الوسيط: {self.data[selected_column].median()}")
+                else:
+                    st.write("القيم الأكثر تكرارًا:")
+                    st.write(self.data[selected_column].value_counts().head())
+            
+            # عرض رسم بياني للعمود المحدد
+            st.subheader(f"رسم بياني لـ {selected_column}")
+            
+            if pd.api.types.is_numeric_dtype(self.data[selected_column]):
+                fig = px.histogram(self.data, x=selected_column, title=f"توزيع {selected_column}")
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                fig = px.bar(self.data[selected_column].value_counts().reset_index(), 
+                             x='index', y=selected_column, title=f"توزيع {selected_column}")
+                fig.update_layout(xaxis_title="القيمة", yaxis_title="العدد")
+                st.plotly_chart(fig, use_container_width=True)
     
-    def _generate_summary(self, df):
-        """توليد ملخص للبيانات"""
-        # محاكاة توليد ملخص
-        return "تحليل البيانات يشير إلى أن هذه المناقصة تتعلق بمشروع إنشائي متوسط الحجم. تتضمن المناقصة متطلبات فنية متوسطة المستوى وشروط تعاقدية معيارية. بناءً على البيانات التاريخية، هناك فرصة جيدة للفوز بهذه المناقصة إذا تم تقديم عرض تنافسي مع التركيز على الجوانب الفنية والجودة."
+    def _advanced_analysis_tab(self):
+        """علامة تبويب التحليل المتقدم"""
+        st.header("تحليل متقدم")
+        
+        if self.data is None:
+            st.info("الرجاء تحميل البيانات أولاً من علامة تبويب 'تحميل البيانات'")
+            return
+        
+        # أنواع التحليل المتقدم
+        analysis_type = st.selectbox(
+            "اختر نوع التحليل:",
+            ["تحليل الارتباط", "تحليل الاتجاهات", "تحليل المجموعات", "تحليل التباين"]
+        )
+        
+        if analysis_type == "تحليل الارتباط":
+            st.subheader("تحليل الارتباط")
+            
+            # اختيار الأعمدة الرقمية فقط
+            numeric_columns = self.data.select_dtypes(include=['number']).columns.tolist()
+            
+            if len(numeric_columns) < 2:
+                st.warning("يجب أن يكون هناك عمودان رقميان على الأقل لإجراء تحليل الارتباط")
+                return
+            
+            # حساب مصفوفة الارتباط
+            correlation_matrix = self.data[numeric_columns].corr()
+            
+            # عرض مصفوفة الارتباط
+            st.write("مصفوفة الارتباط:")
+            st.dataframe(correlation_matrix)
+            
+            # رسم خريطة حرارية للارتباط
+            st.write("خريطة حرارية للارتباط:")
+            fig = px.imshow(correlation_matrix, text_auto=True, aspect="auto",
+                           title="خريطة حرارية لمصفوفة الارتباط")
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # تحليل الارتباط بين عمودين محددين
+            st.subheader("تحليل الارتباط بين عمودين محددين")
+            
+            col1 = st.selectbox("اختر العمود الأول:", numeric_columns, key="corr_col1")
+            col2 = st.selectbox("اختر العمود الثاني:", numeric_columns, key="corr_col2")
+            
+            if col1 != col2:
+                # حساب معامل الارتباط
+                correlation = self.data[col1].corr(self.data[col2])
+                
+                st.write(f"معامل الارتباط بين {col1} و {col2}: {correlation:.4f}")
+                
+                # رسم مخطط التشتت
+                fig = px.scatter(self.data, x=col1, y=col2, title=f"مخطط التشتت: {col1} مقابل {col2}")
+                fig.update_layout(xaxis_title=col1, yaxis_title=col2)
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.warning("الرجاء اختيار عمودين مختلفين")
+        
+        elif analysis_type == "تحليل الاتجاهات":
+            st.subheader("تحليل الاتجاهات")
+            st.info("هذه الميزة قيد التطوير")
+        
+        elif analysis_type == "تحليل المجموعات":
+            st.subheader("تحليل المجموعات")
+            st.info("هذه الميزة قيد التطوير")
+        
+        elif analysis_type == "تحليل التباين":
+            st.subheader("تحليل التباين")
+            st.info("هذه الميزة قيد التطوير")
     
-    def _generate_recommendations(self, df):
-        """توليد توصيات بناءً على البيانات"""
-        # محاكاة توليد توصيات
-        return [
-            "تقديم عرض سعر تنافسي يقل بنسبة 5-10% عن الميزانية التقديرية",
-            "التركيز على الخبرات السابقة في مشاريع مماثلة",
-            "تقديم حلول مبتكرة لتقليل مدة التنفيذ",
-            "تعزيز الجوانب الفنية في العرض",
-            "تقديم خطة تنفيذ مفصلة مع جدول زمني واضح"
-        ]
+    def _visualization_tab(self):
+        """علامة تبويب التصور المرئي"""
+        st.header("التصور المرئي")
+        
+        if self.data is None:
+            st.info("الرجاء تحميل البيانات أولاً من علامة تبويب 'تحميل البيانات'")
+            return
+        
+        # أنواع الرسوم البيانية
+        chart_type = st.selectbox(
+            "اختر نوع الرسم البياني:",
+            ["مخطط شريطي", "مخطط خطي", "مخطط دائري", "مخطط تشتت", "مخطط صندوقي", "مخطط حراري"]
+        )
+        
+        # اختيار الأعمدة حسب نوع الرسم البياني
+        if chart_type == "مخطط شريطي":
+            st.subheader("مخطط شريطي")
+            
+            x_column = st.selectbox("اختر عمود المحور الأفقي (x):", self.data.columns, key="bar_x")
+            y_column = st.selectbox("اختر عمود المحور الرأسي (y):", 
+                                   self.data.select_dtypes(include=['number']).columns.tolist(), 
+                                   key="bar_y")
+            
+            # خيارات إضافية
+            color_column = st.selectbox("اختر عمود اللون (اختياري):", 
+                                       ["لا يوجد"] + self.data.columns.tolist(), 
+                                       key="bar_color")
+            
+            # إنشاء الرسم البياني
+            if color_column == "لا يوجد":
+                fig = px.bar(self.data, x=x_column, y=y_column, title=f"{y_column} حسب {x_column}")
+            else:
+                fig = px.bar(self.data, x=x_column, y=y_column, color=color_column, 
+                            title=f"{y_column} حسب {x_column} (مصنف حسب {color_column})")
+            
+            fig.update_layout(xaxis_title=x_column, yaxis_title=y_column)
+            st.plotly_chart(fig, use_container_width=True)
+        
+        elif chart_type == "مخطط خطي":
+            st.subheader("مخطط خطي")
+            
+            x_column = st.selectbox("اختر عمود المحور الأفقي (x):", self.data.columns, key="line_x")
+            y_columns = st.multiselect("اختر أعمدة المحور الرأسي (y):", 
+                                      self.data.select_dtypes(include=['number']).columns.tolist(), 
+                                      key="line_y")
+            
+            if y_columns:
+                # إنشاء الرسم البياني
+                fig = go.Figure()
+                
+                for y_column in y_columns:
+                    fig.add_trace(go.Scatter(x=self.data[x_column], y=self.data[y_column], 
+                                           mode='lines+markers', name=y_column))
+                
+                fig.update_layout(title=f"مخطط خطي", xaxis_title=x_column, yaxis_title="القيمة")
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.warning("الرجاء اختيار عمود واحد على الأقل للمحور الرأسي")
+        
+        elif chart_type == "مخطط دائري":
+            st.subheader("مخطط دائري")
+            
+            column = st.selectbox("اختر العمود:", self.data.columns, key="pie_column")
+            
+            # إنشاء الرسم البياني
+            fig = px.pie(self.data, names=column, title=f"توزيع {column}")
+            st.plotly_chart(fig, use_container_width=True)
+        
+        elif chart_type == "مخطط تشتت":
+            st.subheader("مخطط تشتت")
+            
+            numeric_columns = self.data.select_dtypes(include=['number']).columns.tolist()
+            
+            if len(numeric_columns) < 2:
+                st.warning("يجب أن يكون هناك عمودان رقميان على الأقل لإنشاء مخطط تشتت")
+                return
+            
+            x_column = st.selectbox("اختر عمود المحور الأفقي (x):", numeric_columns, key="scatter_x")
+            y_column = st.selectbox("اختر عمود المحور الرأسي (y):", numeric_columns, key="scatter_y")
+            
+            # خيارات إضافية
+            color_column = st.selectbox("اختر عمود اللون (اختياري):", 
+                                       ["لا يوجد"] + self.data.columns.tolist(), 
+                                       key="scatter_color")
+            
+            size_column = st.selectbox("اختر عمود الحجم (اختياري):", 
+                                      ["لا يوجد"] + numeric_columns, 
+                                      key="scatter_size")
+            
+            # إنشاء الرسم البياني
+            if color_column == "لا يوجد" and size_column == "لا يوجد":
+                fig = px.scatter(self.data, x=x_column, y=y_column, 
+                                title=f"{y_column} مقابل {x_column}")
+            elif color_column != "لا يوجد" and size_column == "لا يوجد":
+                fig = px.scatter(self.data, x=x_column, y=y_column, color=color_column, 
+                                title=f"{y_column} مقابل {x_column} (مصنف حسب {color_column})")
+            elif color_column == "لا يوجد" and size_column != "لا يوجد":
+                fig = px.scatter(self.data, x=x_column, y=y_column, size=size_column, 
+                                title=f"{y_column} مقابل {x_column} (الحجم حسب {size_column})")
+            else:
+                fig = px.scatter(self.data, x=x_column, y=y_column, color=color_column, size=size_column, 
+                                title=f"{y_column} مقابل {x_column} (مصنف حسب {color_column}, الحجم حسب {size_column})")
+            
+            fig.update_layout(xaxis_title=x_column, yaxis_title=y_column)
+            st.plotly_chart(fig, use_container_width=True)
+        
+        elif chart_type == "مخطط صندوقي":
+            st.subheader("مخطط صندوقي")
+            
+            numeric_columns = self.data.select_dtypes(include=['number']).columns.tolist()
+            
+            if not numeric_columns:
+                st.warning("يجب أن يكون هناك عمود رقمي واحد على الأقل لإنشاء مخطط صندوقي")
+                return
+            
+            y_column = st.selectbox("اختر عمود القيمة:", numeric_columns, key="box_y")
+            
+            # خيارات إضافية
+            x_column = st.selectbox("اختر عمود التصنيف (اختياري):", 
+                                   ["لا يوجد"] + self.data.columns.tolist(), 
+                                   key="box_x")
+            
+            # إنشاء الرسم البياني
+            if x_column == "لا يوجد":
+                fig = px.box(self.data, y=y_column, title=f"مخطط صندوقي لـ {y_column}")
+            else:
+                fig = px.box(self.data, x=x_column, y=y_column, 
+                            title=f"مخطط صندوقي لـ {y_column} حسب {x_column}")
+            
+            st.plotly_chart(fig, use_container_width=True)
+        
+        elif chart_type == "مخطط حراري":
+            st.subheader("مخطط حراري")
+            
+            numeric_columns = self.data.select_dtypes(include=['number']).columns.tolist()
+            
+            if len(numeric_columns) < 2:
+                st.warning("يجب أن يكون هناك عمودان رقميان على الأقل لإنشاء مخطط حراري")
+                return
+            
+            # اختيار الأعمدة للمخطط الحراري
+            selected_columns = st.multiselect("اختر الأعمدة للمخطط الحراري:", 
+                                             numeric_columns, 
+                                             default=numeric_columns[:5] if len(numeric_columns) > 5 else numeric_columns)
+            
+            if selected_columns:
+                # حساب مصفوفة الارتباط
+                correlation_matrix = self.data[selected_columns].corr()
+                
+                # إنشاء الرسم البياني
+                fig = px.imshow(correlation_matrix, text_auto=True, aspect="auto",
+                               title="مخطط حراري لمصفوفة الارتباط")
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.warning("الرجاء اختيار عمود واحد على الأقل")
     
-    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 _reports_tab(self):
+        """علامة تبويب التقارير"""
+        st.header("التقارير")
+        
+        if self.data is None:
+            st.info("الرجاء تحميل البيانات أولاً من علامة تبويب 'تحميل البيانات'")
+            return
+        
+        st.subheader("إنشاء تقرير")
+        
+        # خيارات التقرير
+        report_type = st.selectbox(
+            "اختر نوع التقرير:",
+            ["تقرير ملخص", "تقرير تحليلي", "تقرير مقارنة"]
+        )
+        
+        if report_type == "تقرير ملخص":
+            st.write("محتوى التقرير:")
+            
+            # إنشاء ملخص للبيانات
+            st.write("### ملخص البيانات")
+            st.write(f"عدد الصفوف: {self.data.shape[0]}")
+            st.write(f"عدد الأعمدة: {self.data.shape[1]}")
+            
+            # إحصاءات وصفية
+            st.write("### إحصاءات وصفية")
+            st.dataframe(self.data.describe())
+            
+            # معلومات عن القيم المفقودة
+            st.write("### القيم المفقودة")
+            missing_data = pd.DataFrame({
+                'العمود': self.data.columns,
+                'عدد القيم المفقودة': self.data.isna().sum().values,
+                'نسبة القيم المفقودة (%)': (self.data.isna().sum().values / len(self.data) * 100).round(2)
+            })
+            st.dataframe(missing_data)
+            
+            # توزيع البيانات الرقمية
+            st.write("### توزيع البيانات الرقمية")
+            numeric_columns = self.data.select_dtypes(include=['number']).columns.tolist()
+            
+            if numeric_columns:
+                for i in range(0, len(numeric_columns), 2):
+                    cols = st.columns(2)
+                    for j in range(2):
+                        if i + j < len(numeric_columns):
+                            col = numeric_columns[i + j]
+                            with cols[j]:
+                                fig = px.histogram(self.data, x=col, title=f"توزيع {col}")
+                                st.plotly_chart(fig, use_container_width=True)
+            
+            # خيارات تصدير التقرير
+            st.subheader("تصدير التقرير")
+            export_format = st.radio("اختر صيغة التصدير:", ["PDF", "Excel", "HTML"])
+            
+            if st.button("تصدير التقرير"):
+                st.success(f"تم تصدير التقرير بصيغة {export_format} بنجاح!")
+        
+        elif report_type == "تقرير تحليلي":
+            st.info("هذه الميزة قيد التطوير")
+        
+        elif report_type == "تقرير مقارنة":
+            st.info("هذه الميزة قيد التطوير")
     
-    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.15
-        
-        # إنشاء بيانات التوزيع للرسم البياني
-        cost_data = {
-            "الفئة": ["المواد", "العمالة", "المعدات"],
-            "التكلفة": [materials_cost, labor_cost, equipment_cost]
+    def _create_sample_data(self):
+        """إنشاء بيانات نموذجية للمناقصات"""
+        # إنشاء تواريخ عشوائية
+        start_date = datetime(2023, 1, 1)
+        end_date = datetime(2025, 3, 31)
+        days = (end_date - start_date).days
+        
+        # إنشاء بيانات نموذجية
+        data = {
+            'رقم المناقصة': [f'T-{i:04d}' for i in range(1, 101)],
+            'اسم المشروع': [f'مشروع {i}' for i in range(1, 101)],
+            'نوع المشروع': np.random.choice(['بناء', 'صيانة', 'تطوير', 'توريد', 'خدمات'], 100),
+            'الموقع': np.random.choice(['الرياض', 'جدة', 'الدمام', 'مكة', 'المدينة', 'تبوك', 'أبها'], 100),
+            'تاريخ الإعلان': [start_date + pd.Timedelta(days=np.random.randint(0, days)) for _ in range(100)],
+            'تاريخ الإغلاق': [start_date + pd.Timedelta(days=np.random.randint(30, days)) for _ in range(100)],
+            'الميزانية التقديرية': np.random.uniform(1000000, 50000000, 100),
+            'عدد المتقدمين': np.random.randint(1, 20, 100),
+            'سعر العرض': np.random.uniform(900000, 55000000, 100),
+            'نسبة الفوز (%)': np.random.uniform(0, 100, 100),
+            'مدة التنفيذ (أشهر)': np.random.randint(3, 36, 100),
+            'عدد العمال': np.random.randint(10, 500, 100),
+            'تكلفة المواد': np.random.uniform(500000, 30000000, 100),
+            'تكلفة العمالة': np.random.uniform(200000, 15000000, 100),
+            'تكلفة المعدات': np.random.uniform(100000, 10000000, 100),
+            'هامش الربح (%)': np.random.uniform(5, 25, 100),
+            'درجة المخاطرة': np.random.choice(['منخفضة', 'متوسطة', 'عالية'], 100),
+            'حالة المناقصة': np.random.choice(['جارية', 'مغلقة', 'ملغاة', 'فائزة', 'خاسرة'], 100)
         }
         
         # إنشاء DataFrame
-        cost_df = pd.DataFrame(cost_data)
-        
-        return {
-            'total_budget': total_budget,
-            'materials_cost': materials_cost,
-            'labor_cost': labor_cost,
-            'equipment_cost': equipment_cost,
-            'cost_data': cost_data,
-            'cost_df': cost_df
-        }
-    
-    def _analyze_competition(self, df):
-        """تحليل المنافسة"""
-        # محاكاة تحليل المنافسة
-        competitors = self._get_competitors_data()
-        top_competitors = competitors.nlargest(5, "معدل الفوز (%)").to_dict('records')
-        
-        return {
-            'total_competitors': len(competitors),
-            'top_competitors': top_competitors,
-            'market_position': "متوسط",
-            'competitive_advantage': "الخبرة الفنية والتسعير التنافسي",
-            'threats': ["منافسون جدد في السوق", "تسعير أقل من المنافسين الرئيسيين"]
-        }
-    
-    def _calculate_win_rate(self, df):
-        """حساب معدل الفوز"""
-        # محاكاة حساب ��عدل الفوز
-        if 'الحالة' in df.columns:
-            won_tenders = df[df['الحالة'] == 'فائز']
-            win_rate = len(won_tenders) / len(df) * 100 if len(df) > 0 else 0
-            return win_rate
-        return 45.5  # قيمة افتراضية
-    
-    def _calculate_avg_profit_margin(self, df):
-        """حساب متوسط هامش الربح"""
-        # محاكاة حساب متوسط هامش الربح
-        if 'هامش الربح (%)' in df.columns:
-            return df['هامش الربح (%)'].mean()
-        return 12.3  # قيمة افتراضية
-    
-    def _analyze_price_trends(self, df):
-        """تحليل اتجاهات الأسعار"""
-        # محاكاة تحليل اتجاهات الأسعار
-        return {
-            'trend': 'تصاعدي',
-            'annual_increase': '8.5%',
-            'forecast': 'استمرار الزيادة بنسبة 5-7% سنويًا',
-            'factors': ['زيادة أسعار المواد', 'نقص العمالة', 'زيادة الطلب']
-        }
-    
-    def _identify_success_factors(self, df):
-        """تحديد عوامل النجاح"""
-        # محاكاة تحديد عوامل النجاح
-        return [
-            {'factor': 'السعر التنافسي', 'importance': 'عالي'},
-            {'factor': 'الخبرة السابقة', 'importance': 'عالي'},
-            {'factor': 'جودة العرض الفني', 'importance': 'متوسط'},
-            {'factor': 'مدة التنفيذ', 'importance': 'متوسط'},
-            {'factor': 'سمعة الشركة', 'importance': 'منخفض'}
-        ]
-    
-    def _generate_visualizations(self, df):
-        """توليد الرسومات البيانية"""
-        # محاكاة توليد الرسومات البيانية
-        return {
-            'visualization_urls': [
-                '/static/images/win_rate_chart.png',
-                '/static/images/profit_margin_chart.png',
-                '/static/images/project_types_chart.png'
-            ],
-            'visualization_data': {
-                'win_rate_by_year': [
-                    {'year': '2021', 'win_rate': 42.5},
-                    {'year': '2022', 'win_rate': 45.0},
-                    {'year': '2023', 'win_rate': 48.2},
-                    {'year': '2024', 'win_rate': 47.8}
-                ],
-                'profit_margin_by_project_type': [
-                    {'type': 'مبنى إداري', 'margin': 12.5},
-                    {'type': 'مبنى سكني', 'margin': 10.8},
-                    {'type': 'مدرسة', 'margin': 15.2},
-                    {'type': 'مستشفى', 'margin': 13.7},
-                    {'type': 'طرق', 'margin': 14.3},
-                    {'type': 'جسور', 'margin': 11.2},
-                    {'type': 'بنية تحتية', 'margin': 12.9}
-                ]
-            }
-        }
-    
-    def _generate_success_recommendations(self, factors):
-        """توليد توصيات لزيادة فرص النجاح"""
-        # محاكاة توليد توصيات
-        return [
-            "تخفيض السعر بنسبة 5-8% للحصول على ميزة تنافسية",
-            "التركيز على إبراز الخبرات السابقة في مشاريع مماثلة",
-            "تحسين جودة العرض الفني",
-            "تقديم جدول زمني مختصر للتنفيذ",
-            "تقديم ضمانات إضافية للجودة"
-        ]
-    
-    def _analyze_market_position(self, price, competitors_df):
-        """تحليل الموقف التنافسي في السوق"""
-        # محاكاة تحليل الموقف التنافسي
-        return {
-            'position': 'متوسط',
-            'price_percentile': 45,
-            'competitors_lower': 3,
-            'competitors_higher': 7,
-            'recommendation': 'تخفيض السعر بشكل طفيف للحصول على موقف تنافسي أفضل'
-        }
-    
-    def _generate_pricing_recommendations(self, optimal_price, price_sensitivity):
-        """توليد توصيات التسعير"""
-        # محاكاة توليد توصيات التسعير
-        return [
-            f"السعر الأمثل هو {optimal_price:,.0f} ريال",
-            "تجنب تخفيض السعر أكثر من 15% من الميزانية التقديرية",
-            "التركيز على تقديم قيمة إضافية بدلاً من تخفيض السعر بشكل كبير",
-            "في حالة المنافسة الشديدة، يمكن تخفيض السعر بنسبة إضافية 3%",
-            "تقديم خيارات سعرية بديلة مع اختلاف نطاق العمل"
-        ]
+        df = pd.DataFrame(data)
+        
+        # إضافة بعض العلاقات المنطقية
+        df['إجمالي التكلفة'] = df['تكلفة المواد'] + df['تكلفة العمالة'] + df['تكلفة المعدات']
+        df['الربح المتوقع'] = df['سعر العرض'] - df['إجمالي التكلفة']
+        df['نسبة التكلفة من العرض (%)'] = (df['إجمالي التكلفة'] / df['سعر العرض'] * 100).round(2)
+        
+        return df