Update app.py

app.py

@@ -1,4 +1,5 @@
 import streamlit as st
+from streamlit_lottie import st_lottie
 from streamlit_option_menu import option_menu
 import requests
 import pandas as pd
@@ -16,506 +17,320 @@ import dns.resolver
 from urllib.parse import urlparse
 import json
 import numpy as np
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from webdriver_manager.chrome import ChromeDriverManager
 from PIL import Image
 import io
 import time
-import matplotlib.pyplot as plt
-import seaborn as sns
-from datetime import timedelta
-import tldextract
-from concurrent.futures import ThreadPoolExecutor
-import re
-from collections import Counter
-from wordcloud import WordCloud
-import advertools as adv
 
-# تحسين مظهر الصفحة
-st.set_page_config(
-    layout="wide",
-    page_title="محلل المواقع المتقدم | Website Analyzer Pro",
-    page_icon="🔍",
-    initial_sidebar_state="expanded"
-)
+# تخصيص المظهر
+st.set_page_config(layout="wide", page_title="محلل المواقع المتقدم")
 
-# تحسين التصميم باستخدام CSS المحسن
+# تحميل الأنيميشن
+def load_lottieurl(url):
+    try:
+        r = requests.get(url)
+        r.raise_for_status()
+        return r.json()
+    except Exception as e:
+        # Fallback to a basic loading animation JSON
+        return {
+            "v": "5.5.7",
+            "fr": 29.9700012207031,
+            "ip": 0,
+            "op": 180.00000733155,
+            "w": 500,
+            "h": 500,
+            "nm": "Loading",
+            "ddd": 0,
+            "assets": [],
+            "layers": [
+                {
+                    "ddd": 0,
+                    "ind": 1,
+                    "ty": 4,
+                    "nm": "Loading Circle",
+                    "sr": 1,
+                    "ks": {
+                        "o": {"a": 0, "k": 100, "ix": 11},
+                        "r": {"a": 1, "k": [{"i": {"x": [0.833], "y": [0.833]}, "o": {"x": [0.167], "y": [0.167]}, "t": 0, "s": [0], "e": [360]}, {"t": 180.00000733155}], "ix": 10}
+                    }
+                }
+            ]
+        }
+
+# تحميل الأنيميشن الافتراضي
+lottie_analyzing = load_lottieurl("https://assets5.lottiefiles.com/packages/lf20_qpwbqki6.json")
+
+# تصميم CSS مخصص
 st.markdown("""
 <style>
-    @import url('https://fonts.googleapis.com/css2?family=Tajawal:wght@400;500;700&display=swap');
-    
-    * {
-        font-family: 'Tajawal', sans-serif;
-    }
-    
     .main {
-        background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
-        padding: 20px;
-    }
-    
-    .metric-card {
-        background: white;
-        border-radius: 15px;
-        padding: 20px;
-        box-shadow: 0 4px 15px rgba(0,0,0,0.1);
-        transition: all 0.3s ease;
-        margin-bottom: 20px;
+        background-color: #f0f2f6;
     }
-    
-    .metric-card:hover {
-        transform: translateY(-5px);
-        box-shadow: 0 8px 25px rgba(0,0,0,0.15);
-    }
-    
-    .metric-value {
-        font-size: 2em;
-        font-weight: bold;
-        color: #2196F3;
-    }
-    
-    .metric-label {
-        color: #666;
-        font-size: 1.1em;
-    }
-    
     .stButton>button {
-        background: linear-gradient(45deg, #2196F3, #21CBF3);
         color: white;
-        border-radius: 25px;
-        padding: 15px 30px;
+        background-color: #ff4b4b;
+        border-radius: 10px;
+        padding: 15px 25px;
         border: none;
-        box-shadow: 0 4px 15px rgba(33,150,243,0.3);
-        transition: all 0.3s ease;
-        font-size: 1.1em;
-        font-weight: 500;
-        width: 100%;
     }
-    
     .stButton>button:hover {
-        transform: translateY(-2px);
-        box-shadow: 0 6px 20px rgba(33,150,243,0.4);
-    }
-    
-    h1, h2, h3 {
-        color: #1E3D59;
-        font-weight: 700;
-    }
-    
-    .stTextInput>div>div>input {
-        border-radius: 10px;
-        border: 2px solid #E0E0E0;
-        padding: 12px;
-        font-size: 1.1em;
-        transition: all 0.3s ease;
-    }
-    
-    .stTextInput>div>div>input:focus {
-        border-color: #2196F3;
-        box-shadow: 0 0 0 2px rgba(33,150,243,0.2);
+        background-color: #ff6b6b;
+        border: none;
     }
-    
-    .streamlit-expanderHeader {
+    .metric-card {
         background-color: white;
         border-radius: 10px;
-        padding: 10px;
-        box-shadow: 0 2px 8px rgba(0,0,0,0.1);
-    }
-    
-    .stProgress > div > div > div {
-        background-color: #2196F3;
-    }
-    
-    .tab-content {
         padding: 20px;
-        background: white;
-        border-radius: 15px;
-        box-shadow: 0 4px 15px rgba(0,0,0,0.1);
-    }
-    
-    .insight-card {
-        background: #f8f9fa;
-        border-right: 4px solid #2196F3;
-        padding: 15px;
-        margin: 10px 0;
-        border-radius: 8px;
-    }
-    
-    .chart-container {
-        background: white;
-        padding: 20px;
-        border-radius: 15px;
-        box-shadow: 0 4px 15px rgba(0,0,0,0.1);
-        margin: 20px 0;
+        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
     }
 </style>
 """, unsafe_allow_html=True)
 
-class AdvancedWebsiteAnalyzer:
+class WebsiteAnalyzer:
     def __init__(self):
         self.headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
         }
-        self.history = self.load_history()
-    
-    def load_history(self):
-        try:
-            return pd.read_csv('analysis_history.csv')
-        except:
-            return pd.DataFrame(columns=['url', 'timestamp', 'performance_score', 'seo_score', 'security_score'])
-    
-    def save_history(self, data):
-        self.history = self.history.append(data, ignore_index=True)
-        self.history.to_csv('analysis_history.csv', index=False)
-    
+
     async def analyze_performance(self, url):
         try:
             start_time = time.time()
             async with httpx.AsyncClient() as client:
                 response = await client.get(url)
                 load_time = time.time() - start_time
-                page_size = len(response.content) / 1024
+                page_size = len(response.content) / 1024  # KB
                 
-                # تحليل الصور والموارد
-                soup = BeautifulSoup(response.text, 'html.parser')
-                images = soup.find_all('img')
-                scripts = soup.find_all('script')
-                css_files = soup.find_all('link', {'rel': 'stylesheet'})
-                
-                performance_metrics = {
-                    "زمن التحميل": round(load_time, 2),
-                    "حجم الصفحة": round(page_size, 2),
-                    "حالة الاستجابة": response.status_code,
-                    "عدد الصور": len(images),
-                    "عدد ملفات JavaScript": len(scripts),
-                    "عدد ملفات CSS": len(css_files),
-                    "تقييم الأداء": self._calculate_performance_score(load_time, page_size, len(images), len(scripts)),
-                    "توصيات التحسين": self._get_performance_recommendations(load_time, page_size, len(images), len(scripts))
+                return {
+                    "load_time": round(load_time, 2),
+                    "page_size": round(page_size, 2),
+                    "status_code": response.status_code
                 }
-                
-                # إضافة تحليل الموارد
-                resources_analysis = await self._analyze_resources(url)
-                performance_metrics.update(resources_analysis)
-                
-                return performance_metrics
         except Exception as e:
-            return {"error": f"خطأ في تحليل الأداء: {str(e)}"}
+            return {"error": str(e)}
 
-    async def _analyze_resources(self, url):
+    async def analyze_seo(self, url):
         try:
             async with httpx.AsyncClient() as client:
                 response = await client.get(url)
                 soup = BeautifulSoup(response.text, 'html.parser')
                 
+                # تحليل العناوين مع تقييم
+                headings = {
+                    'h1': len(soup.find_all('h1')),
+                    'h2': len(soup.find_all('h2')),
+                    'h3': len(soup.find_all('h3'))
+                }
+                
+                # تقييم العناوين
+                heading_score = 0
+                if headings['h1'] > 0:
+                    heading_score += 20  # تأكد من وجود H1
+                heading_score += min(headings['h2'], 3) * 5  # حتى 3 عناوين H2
+                heading_score += min(headings['h3'], 3) * 3  # حتى 3 عناوين H3
+                
+                # تحليل الروابط
+                links = soup.find_all('a')
+                internal_links = len([link for link in links if urlparse(link.get('href', '')).netloc == urlparse(url).netloc])
+                external_links = len(links) - internal_links
+                
                 # تحليل الصور
                 images = soup.find_all('img')
-                image_sizes = []
-                for img in images[:5]:  # تحليل أول 5 صور فقط لتجنب البطء
-                    if img.get('src'):
-                        try:
-                            img_response = await client.get(img['src'])
-                            image_sizes.append(len(img_response.content) / 1024)
-                        except:
-                            continue
+                images_without_alt = len([img for img in images if not img.get('alt')])
+                images_alt_score = max(0, 100 - (images_without_alt * 5))  # خصم 5 نقاط لكل صورة بدون Alt
+                
+                # تحليل العنوان والوصف
+                title = soup.title.string if soup.title else "لا يوجد عنوان"
+                meta_description = soup.find("meta", {"name": "description"}) or soup.find("meta", {"property": "og:description"})
+                description_text = meta_description.get("content") if meta_description else "لا يوجد وصف"
+                
+                # حساب نقاط العنوان والوصف
+                title_score = 0
+                if title and len(title) > 10 and len(title) <= 60:
+                    title_score = 20
+                
+                description_score = 0
+                if description_text != "لا يوجد وصف" and 70 <= len(description_text) <= 160:
+                    description_score = 20
+                
+                # حساب النقاط الإجمالية
+                total_seo_score = heading_score + images_alt_score + title_score + description_score
                 
                 return {
-                    "تحليل الموارد": {
-                        "متوسط حجم الصور": round(np.mean(image_sizes), 2) if image_sizes else 0,
-                        "عدد الموارد الخارجية": len(soup.find_all(['script', 'link', 'img'])),
-                        "توصيات تحسين الموارد": self._get_resource_recommendations(image_sizes)
+                    "title": {
+                        "text": title,
+                        "score": title_score,
+                        "recommendation": "يجب أن يكون العنوان بين 10-60 حرفًا" if title_score == 0 else "العنوان مثالي"
+                    },
+                    "meta_description": {
+                        "text": description_text,
+                        "score": description_score,
+                        "recommendation": "يجب أن يكون الوصف بين 70-160 حرفًا" if description_score == 0 else "الوصف مثالي"
+                    },
+                    "headings": {
+                        "details": headings,
+                        "score": heading_score,
+                        "recommendation": "تأكد من وجود عنوان H1 واستخدم العناوين الفرعية بشكل هرمي"
+                    },
+                    "internal_links": {
+                        "count": internal_links,
+                        "score": min(internal_links, 20),
+                        "recommendation": "الروابط الداخلية جيدة للتنقل وتحسين SEO"
+                    },
+                    "external_links": {
+                        "count": external_links,
+                        "recommendation": "استخدم الروابط الخارجية بحكمة للمصداقية"
+                    },
+                    "images": {
+                        "total": len(images),
+                        "without_alt": images_without_alt,
+                        "alt_score": images_alt_score,
+                        "recommendation": f"أضف نص بديل لـ {images_without_alt} صورة"
+                    },
+                    "total_seo_score": {
+                        "score": total_seo_score,
+                        "max_score": 100,
+                        "grade": (
+                            "ممتاز" if total_seo_score >= 80 else
+                            "جيد" if total_seo_score >= 60 else
+                            "متوسط" if total_seo_score >= 40 else
+                            "ضعيف"
+                        )
                     }
                 }
         except Exception as e:
-            return {"error": f"خطأ في تحليل الموارد: {str(e)}"}
+            return {"error": str(e)}
 
-    def _calculate_performance_score(self, load_time, page_size, image_count, script_count):
-        score = 100
-        
-        # تأثير زمن التحميل
-        if load_time > 2:
-            score -= min(30, (load_time - 2) * 10)
+    def analyze_security(self, url):
+        try:
+            domain = urlparse(url).netloc
             
-        # تأثير حجم الصفحة
-        if page_size > 1000:
-            score -= min(20, (page_size - 1000) / 100)
+            # فحص SSL
+            ctx = ssl.create_default_context()
+            with ctx.wrap_socket(socket.socket(), server_hostname=domain) as s:
+                s.connect((domain, 443))
+                cert = s.getpeercert()
             
-        # تأثير عدد الصور
-        if image_count > 10:
-            score -= min(15, (image_count - 10) * 1.5)
+            # فحص DNS
+            dns_records = {
+                'A': [str(r) for r in dns.resolver.resolve(domain, 'A')],
+                'MX': [str(r) for r in dns.resolver.resolve(domain, 'MX')],
+                'TXT': [str(r) for r in dns.resolver.resolve(domain, 'TXT')]
+            }
             
-        # تأثير عدد ملفات JavaScript
-        if script_count > 5:
-            score -= min(15, (script_count - 5) * 2)
+            # معلومات WHOIS
+            domain_info = whois.whois(domain)
             
-        return max(0, round(score))
+            return {
+                "ssl_valid": True,
+                "ssl_expiry": cert['notAfter'],
+                "dns_records": dns_records,
+                "domain_info": {
+                    "registrar": domain_info.registrar,
+                    "creation_date": domain_info.creation_date,
+                    "expiration_date": domain_info.expiration_date
+                }
+            }
+        except Exception as e:
+            return {"error": str(e)}
 
-    def _get_performance_recommendations(self, load_time, page_size, image_count, script_count):
-        recommendations = []
-        
-        if load_time > 2:
-            recommendations.append({
-                "المشكلة": "بطء زمن التحميل",
-                "الحل": "تحسين سرعة الخادم وتفعيل التخزين المؤقت",
-                "الأولوية": "عالية"
-            })
-            
-        if page_size > 1000:
-            recommendations.append({
-                "المشكلة": "حجم الصفحة كبير",
-                "الحل": "ضغط الملفات وتحسين الكود",
-                "الأولوية": "متوسطة"
-            })
+    async def take_screenshot(self, url):
+        try:
+            chrome_options = Options()
+            chrome_options.add_argument('--headless')
+            chrome_options.add_argument('--no-sandbox')
+            chrome_options.add_argument('--disable-dev-shm-usage')
             
-        if image_count > 10:
-            recommendations.append({
-                "المشكلة": "عدد كبير من الصور",
-                "الحل": "تحسين حجم الصور واستخدام التحميل الكسول",
-                "الأولوية": "متوسطة"
-            })
+            driver = webdriver.Chrome(ChromeDriverManager().install(), options=chrome_options)
+            driver.get(url)
+            driver.set_window_size(1920, 1080)
             
-        if script_count > 5:
-            recommendations.append({
-                "المشكلة": "عدد كبير من ملفات JavaScript",
-                "الحل": "دمج وضغط ملفات JavaScript",
-                "الأولوية": "عالية"
-            })
+            screenshot = driver.get_screenshot_as_png()
+            driver.quit()
             
-        return recommendations if recommendations else [{"المشكلة": "لا توجد مشاكل", "الحل": "الأداء جيد!", "الأولوية": "منخفضة"}]
-
-    async def analyze_seo(self, url):
-        try:
-            async with httpx.AsyncClient() as client:
-                response = await client.get(url)
-                soup = BeautifulSoup(response.text, 'html.parser')
-                
-                # تحليل المحتوى
-                content_analysis = self._analyze_content(soup)
-                
-                # تحليل الروابط
-                links_analysis = self._analyze_links(soup)
-                
-                # تحليل الكلمات المفتاحية
-                keywords_analysis = self._extract_keywords(soup)
-                
-                seo_analysis = {
-                    "تحليل العنوان": self._analyze_title(soup),
-                    "تحليل الوصف": self._analyze_description(soup),
-                    "تحليل الكلمات المفتاحية": keywords_analysis,
-                    "تحليل العناوين": self._analyze_headings(soup),
-                    "تحليل الروابط": links_analysis,
-                    "تحليل المحتوى": content_analysis,
-                    "تقييم SEO": self._calculate_seo_score(soup),
-                    "توصيات تحسين SEO": self._get_seo_recommendations(soup)
-                }
-                
-                return seo_analysis
+            return Image.open(io.BytesIO(screenshot))
         except Exception as e:
-            return {"error": f"خطأ في تحليل SEO: {str(e)}"}
-
-    def _analyze_content(self, soup):
-        # استخراج النص
-        text_content = ' '.join([p.text for p in soup.find_all('p')])
-        
-        # تحليل طول المحتوى
-        word_count = len(text_content.split())
-        
-        # تحليل قراءة المحتوى
-        readability_score = self._calculate_readability(text_content)
-        
-        # تحليل كثافة الكلمات المفتاحية
-        keyword_density = self._calculate_keyword_density(text_content)
-        
-        return {
-            "عدد الكلمات": word_count,
-            "مستوى القراءة": readability_score,
-            "كثافة الكلمات المفتاحية": keyword_density,
-            "التقييم": "ممتاز" if word_count > 300 and readability_score > 60 else "يحتاج تحسين"
-        }
-
-    def _calculate_readability(self, text):
-        # حساب مؤشر بسيط لسهولة القراءة
-        sentences = len(re.split(r'[.!?]+', text))
-        words = len(text.split())
-        if sentences == 0:
-            return 0
-        return min(100, round((words / sentences) * 10))
-
-    def _calculate_keyword_density(self, text):
-        words = text.lower().split()
-        word_freq = Counter(words)
-        total_words = len(words)
-        
-        if total_words == 0:
-            return {}
-            
-        return {word: round((count / total_words) * 100, 2) 
-                for word, count in word_freq.most_common(5)}
+            return None
 
-    def analyze_security(self, url):
-    try:
-        domain = urlparse(url).netloc
-        whois_info = self._get_whois_info(domain)
+def main():
+    st.title("🔍 محلل المواقع المتقدم")
+    
+    # إضافة قائمة جانبية
+    with st.sidebar:
+        selected = option_menu(
+            menu_title="القائمة الرئيسية",
+            options=["تحليل جديد", "التقارير السابقة", "الإعدادات"],
+            icons=["search", "file-text", "gear"],
+            menu_icon="cast",
+            default_index=0,
+        )
+    
+    if selected == "تحليل جديد":
+        col1, col2 = st.columns([2, 1])
         
-        security_analysis = {
-            "تحليل SSL": self._check_ssl(url),
-            "تحليل DNS": self._check_dns(domain),
-            "تحليل Headers": self._check_security_headers(url),
-            "فحص المخاطر": self._check_security_risks(url),
-            "معلومات Whois": whois_info,
-            "تقييم الأمان": self._calculate_security_score(url),
-            "توصيات الأمان": self._get_security_recommendations(url)
-        }
-        return security_analysis
-    except Exception as e:
-        return {"error": f"خطأ في تحليل الأمان: {str(e)}"}
-
-def _get_whois_info(self, domain):
-    try:
-        w = whois.whois(domain)
-        return {
-            "اسم النطاق": domain,
-            "تاريخ التسجيل": str(w.creation_date),
-            "تاريخ الانتهاء": str(w.expiration_date),
-            "المسجل": w.registrar,
-            "الحالة": w.status
-        }
-    except:
-        return {"error": "لا يمكن الحصول على معلومات Whois"}
-
-def _check_ssl(self, url):
-    try:
-        context = ssl.create_default_context()
-        with socket.create_connection((urlparse(url).netloc, 443)) as sock:
-            with context.wrap_socket(sock, server_hostname=urlparse(url).netloc) as ssock:
-                cert = ssock.getpeercert()
-                return {
-                    "الحالة": "آمن ✅",
-                    "نوع الشهادة": cert.get('subject', {}).get('commonName', 'Unknown'),
-                    "تاريخ الإصدار": cert.get('notBefore', 'Unknown'),
-                    "تاريخ الانتهاء": cert.get('notAfter', 'Unknown'),
-                    "الخوارزمية": ssock.cipher()[0],
-                    "قوة التشفير": f"{ssock.cipher()[2]} bits"
-                }
-    except:
-        return {
-            "الحالة": "غير آمن ❌",
-            "السبب": "لا يوجد شهادة SSL صالحة"
-        }
-
-def _check_security_headers(self, url):
-    try:
-        response = requests.get(url)
-        headers = response.headers
-        security_headers = {
-            'Strict-Transport-Security': 'HSTS',
-            'Content-Security-Policy': 'CSP',
-            'X-Frame-Options': 'X-Frame',
-            'X-Content-Type-Options': 'X-Content-Type',
-            'X-XSS-Protection': 'XSS Protection'
-        }
+        with col1:
+            url = st.text_input("أدخل رابط الموقع", "https://example.com")
+            if st.button("بدء التحليل"):
+                with st.spinner("جاري التحليل..."):
+                    st_lottie(lottie_analyzing, height=200)
+                    
+                    analyzer = WebsiteAnalyzer()
+                    
+                    # تحليل متزامن
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    performance_data = loop.run_until_complete(analyzer.analyze_performance(url))
+                    seo_data = loop.run_until_complete(analyzer.analyze_seo(url))
+                    security_data = analyzer.analyze_security(url)
+                    screenshot = loop.run_until_complete(analyzer.take_screenshot(url))
+                    
+                    # عرض النتائج
+                    st.success("تم اكتمال التحليل!")
+                    
+                    # عرض البطاقات الإحصائية
+                    cols = st.columns(3)
+                    with cols[0]:
+                        st.metric("زمن التحميل", f"{performance_data.get('load_time', 'N/A')}s")
+                    with cols[1]:
+                        st.metric("حجم الصفحة", f"{performance_data.get('page_size', 'N/A')} KB")
+                    with cols[2]:
+                        st.metric("الروابط الداخلية", seo_data.get('internal_links', 'N/A')['count'])
+                    
+                    # عرض تحليل SEO
+                    with st.expander("تحليل SEO", expanded=True):
+                        st.json(seo_data)
+                        
+                        # رسم بياني للعناوين
+                        if 'headings' in seo_data and 'details' in seo_data['headings']:
+                            fig = px.bar(
+                                x=list(seo_data['headings']['details'].keys()),
+                                y=list(seo_data['headings']['details'].values()),
+                                title="توزيع العناوين",
+                                labels={'x': 'نوع العنوان', 'y': 'العدد'}
+                            )
+                            st.plotly_chart(fig)
+                    
+                    # عرض تحليل الأمان
+                    with st.expander("تحليل الأمان", expanded=True):
+                        st.json(security_data)
+                    
+                    # عرض لقطة الشاشة
+                    if screenshot:
+                        st.image(screenshot, caption="لقطة شاشة للموقع", use_column_width=True)
         
-        results = {}
-        for header, name in security_headers.items():
-            results[name] = {
-                "موجود": header in headers,
-                "القيمة": headers.get(header, "غير موجود")
-            }
-        return results
-    except:
-        return {"error": "فشل فحص headers الأمان"}
-
-def _check_security_risks(self, url):
-    risks = []
-    
-    # فحص بروتوكول HTTP
-    if not url.startswith('https'):
-        risks.append({
-            "المستوى": "عالي",
-            "النوع": "بروتوكول غير آمن",
-            "الوصف": "الموقع يستخدم HTTP بدلاً من HTTPS"
-        })
-    
-    # فحص تحديث شهادة SSL
-    ssl_info = self._check_ssl(url)
-    if ssl_info.get("الحالة") == "غير آمن ❌":
-        risks.append({
-            "المستوى": "عالي",
-            "النوع": "شهادة SSL",
-            "الوصف": "شهادة SSL غير صالحة أو منتهية"
-        })
-    
-    # فحص headers الأمان
-    headers = self._check_security_headers(url)
-    if isinstance(headers, dict) and not headers.get("HSTS", {}).get("موجود"):
-        risks.append({
-            "المستوى": "متوسط",
-            "النوع": "HSTS غير مفعل",
-            "الوصف": "عدم وجود حماية النقل الآمن الصارم"
-        })
-    
-    return {
-        "المخاطر المكتشفة": risks,
-        "عدد المخاطر": len(risks),
-        "مستوى الخطورة": "عالي" if any(r["المستوى"] == "عالي" for r in risks) else "متوسط" if risks else "منخفض"
-    }
-
-def _calculate_security_score(self, url):
-    score = 100
+        with col2:
+            st.subheader("آخر التحليلات")
+            # هنا يمكن إضافة قائمة بآخر المواقع التي تم تحليلها
     
-    # فحص HTTPS
-    if not url.startswith('https'):
-        score -= 30
+    elif selected == "التقارير السابقة":
+        st.subheader("التقارير السابقة")
+        # هنا يمكن إضافة عرض للتقارير السابقة
     
-    # فحص SSL
-    ssl_info = self._check_ssl(url)
-    if ssl_info.get("الحالة") == "غير آمن ❌":
-        score -= 25
-    
-    # فحص Headers
-    headers = self._check_security_headers(url)
-    if isinstance(headers, dict):
-        for header_info in headers.values():
-            if not header_info.get("موجود"):
-                score -= 5
-    
-    # فحص مخاطر الأمان
-    risks = self._check_security_risks(url)
-    score -= (risks.get("عدد المخاطر", 0) * 10)
-    
-    return max(0, score)
+    elif selected == "الإعدادات":
+        st.subheader("إعدادات التحليل")
+        # هنا يمكن إضافة إعدادات التحليل
 
-def _get_security_recommendations(self, url):
-    recommendations = []
-    
-    # فحص HTTPS
-    if not url.startswith('https'):
-        recommendations.append({
-            "المشكلة": "عدم استخدام HTTPS",
-            "الحل": "قم بتفعيل HTTPS وتثبيت شهادة SSL",
-            "الأولوية": "عالية"
-        })
-    
-    # فحص SSL
-    ssl_info = self._check_ssl(url)
-    if ssl_info.get("الحالة") == "غير آمن ❌":
-        recommendations.append({
-            "المشكلة": "شهادة SSL غير صالحة",
-            "الحل": "قم بتجديد أو تثبيت شهادة SSL جديدة",
-            "الأولوية": "عالية"
-        })
-    
-    # فحص Headers
-    headers = self._check_security_headers(url)
-    if isinstance(headers, dict):
-        for name, info in headers.items():
-            if not info.get("موجود"):
-                recommendations.append({
-                    "المشكلة": f"عدم وجود {name}",
-                    "الحل": f"قم بإضافة header الأمان {name}",
-                    "الأولوية": "متوسطة"
-                })
-    
-    return recommendations if recommendations else [
-        {
-            "المشكلة": "لا توجد مشاكل أمنية واضحة",
-            "الحل": "استمر في مراقبة وتحديث إعدادات الأمان",
-            "الأولوية": "منخفضة"
-        }
-    ]
+if __name__ == "__main__":
+    main()