Update app.py

app.py

@@ -29,7 +29,7 @@ from collections import Counter
 from wordcloud import WordCloud
 import advertools as adv
 
-# تحسين مظهر الصفحة
+# Page configuration
 st.set_page_config(
     layout="wide",
     page_title="محلل المواقع المتقدم | Website Analyzer Pro",
@@ -37,7 +37,7 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# تحسين التصميم باستخدام CSS المحسن
+# Custom CSS
 st.markdown("""
 <style>
     @import url('https://fonts.googleapis.com/css2?family=Tajawal:wght@400;500;700&display=swap');
@@ -162,7 +162,7 @@ class AdvancedWebsiteAnalyzer:
             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 = pd.concat([self.history, pd.DataFrame([data])], ignore_index=True)
         self.history.to_csv('analysis_history.csv', index=False)
     
     async def analyze_performance(self, url):
@@ -173,7 +173,6 @@ class AdvancedWebsiteAnalyzer:
                 load_time = time.time() - start_time
                 page_size = len(response.content) / 1024
                 
-                # تحليل الصور والموارد
                 soup = BeautifulSoup(response.text, 'html.parser')
                 images = soup.find_all('img')
                 scripts = soup.find_all('script')
@@ -190,7 +189,6 @@ class AdvancedWebsiteAnalyzer:
                     "توصيات التحسين": self._get_performance_recommendations(load_time, page_size, len(images), len(scripts))
                 }
                 
-                # إضافة تحليل الموارد
                 resources_analysis = await self._analyze_resources(url)
                 performance_metrics.update(resources_analysis)
                 
@@ -204,10 +202,9 @@ class AdvancedWebsiteAnalyzer:
                 response = await client.get(url)
                 soup = BeautifulSoup(response.text, 'html.parser')
                 
-                # تحليل الصور
                 images = soup.find_all('img')
                 image_sizes = []
-                for img in images[:5]:  # تحليل أول 5 صور فقط لتجنب البطء
+                for img in images[:5]:
                     if img.get('src'):
                         try:
                             img_response = await client.get(img['src'])
@@ -225,25 +222,41 @@ class AdvancedWebsiteAnalyzer:
         except Exception as e:
             return {"error": f"خطأ في تحليل الموارد: {str(e)}"}
 
+    def _get_resource_recommendations(self, image_sizes):
+        recommendations = []
+        
+        if image_sizes:
+            avg_size = np.mean(image_sizes)
+            if avg_size > 100:
+                recommendations.append({
+                    "المشكلة": "حجم الصور كبير",
+                    "الحل": "ضغط الصور وتحسين جودتها",
+                    "الأولوية": "عالية"
+                })
+                
+        return recommendations if recommendations else [
+            {
+                "المشكلة": "لا توجد مشاكل",
+                "الحل": "الموارد محسنة بشكل جيد",
+                "الأولوية": "منخفضة"
+            }
+        ]
+
     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)
-            
-        # تأثير حجم الصفحة
+        
         if page_size > 1000:
             score -= min(20, (page_size - 1000) / 100)
-            
-        # تأثير عدد الصور
+        
         if image_count > 10:
             score -= min(15, (image_count - 10) * 1.5)
-            
-        # تأثير عدد ملفات JavaScript
+        
         if script_count > 5:
             score -= min(15, (script_count - 5) * 2)
-            
+        
         return max(0, round(score))
 
     def _get_performance_recommendations(self, load_time, page_size, image_count, script_count):
@@ -255,28 +268,28 @@ class AdvancedWebsiteAnalyzer:
                 "الحل": "تحسين سرعة الخادم وتفعيل التخزين المؤقت",
                 "الأولوية": "عالية"
             })
-            
+        
         if page_size > 1000:
             recommendations.append({
                 "المشكلة": "حجم الصفحة كبير",
                 "الحل": "ضغط الملفات وتحسين الكود",
                 "الأولوية": "متوسطة"
             })
-            
+        
         if image_count > 10:
             recommendations.append({
                 "المشكلة": "عدد كبير من الصور",
                 "الحل": "تحسين حجم الصور واستخدام التحميل الكسول",
                 "الأولوية": "متوسطة"
             })
-            
+        
         if script_count > 5:
             recommendations.append({
                 "المشكلة": "عدد كبير من ملفات JavaScript",
                 "الحل": "دمج وضغط ملفات JavaScript",
                 "الأولوية": "عالية"
             })
-            
+        
         return recommendations if recommendations else [{"المشكلة": "لا توجد مشاكل", "الحل": "الأداء جيد!", "الأولوية": "منخفضة"}]
 
     async def analyze_seo(self, url):
@@ -285,13 +298,8 @@ class AdvancedWebsiteAnalyzer:
                 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 = {
@@ -309,563 +317,221 @@ class AdvancedWebsiteAnalyzer:
         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)
-        
+    def _analyze_title(self, soup):
+        title = soup.find('title')
+        title_text = title.text if title else ""
         return {
-            "عدد الكلمات": word_count,
-            "مستوى القراءة": readability_score,
-            "كثافة الكلمات المفتاحية": keyword_density,
-            "التقييم": "ممتاز" if word_count > 300 and readability_score > 60 else "يحتاج تحسين"
+            "العنوان": title_text,
+            "الطول": len(title_text),
+            "التقييم": "جيد" if 30 <= len(title_text) <= 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)}
-
-   import streamlit as st
-from streamlit_option_menu import option_menu
-import requests
-import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go
-from datetime import datetime
-import httpx
-import asyncio
-import aiohttp
-from bs4 import BeautifulSoup
-import whois
-import ssl
-import socket
-import dns.resolver
-from urllib.parse import urlparse
-import json
-import numpy as np
-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"
-)
-
-# تحسين التصميم باستخدام 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;
-    }
-    
-    .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;
-        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);
-    }
-    
-    .streamlit-expanderHeader {
-        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;
-    }
-</style>
-""", unsafe_allow_html=True)
-
-class AdvancedWebsiteAnalyzer:
-    def __init__(self):
-        self.headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+    def _analyze_description(self, soup):
+        meta_desc = soup.find('meta', {'name': 'description'})
+        desc_text = meta_desc.get('content', '') if meta_desc else ""
+        return {
+            "الوصف": desc_text,
+            "الطول": len(desc_text),
+            "التقييم": "جيد" if 120 <= len(desc_text) <= 160 else "يحتاج تحسين"
         }
-        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
-                
-                # تحليل الصور والموارد
-                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))
-                }
-                
-                # إضافة تحليل الموارد
-                resources_analysis = await self._analyze_resources(url)
-                performance_metrics.update(resources_analysis)
-                
-                return performance_metrics
-        except Exception as e:
-            return {"error": f"خطأ في تحليل الأداء: {str(e)}"}
 
-    async def _analyze_resources(self, url):
-        try:
-            async with httpx.AsyncClient() as client:
-                response = await client.get(url)
-                soup = BeautifulSoup(response.text, 'html.parser')
-                
-                # تحليل الصور
-                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
-                
-                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)
-                    }
-                }
-        except Exception as e:
-            return {"error": f"خطأ في تحليل الموارد: {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)
-            
-        # تأثير حجم الصفحة
-        if page_size > 1000:
-            score -= min(20, (page_size - 1000) / 100)
-            
-        # تأثير عدد الصور
-        if image_count > 10:
-            score -= min(15, (image_count - 10) * 1.5)
-            
-        # تأثير عدد ملفات JavaScript
-        if script_count > 5:
-            score -= min(15, (script_count - 5) * 2)
-            
-        return max(0, round(score))
+    def _analyze_headings(self, soup):
+        headings = {}
+        for i in range(1, 7):
+            h_tags = soup.find_all(f'h{i}')
+            headings[f'h{i}'] = {
+                "العدد": len(h_tags),
+                "النصوص": [h.text.strip() for h in h_tags]
+            }
+        return headings
 
-    def _get_performance_recommendations(self, load_time, page_size, image_count, script_count):
-        recommendations = []
+    def _analyze_links(self, soup):
+        links = soup.find_all('a')
+        internal_links = []
+        external_links = []
+        broken_links = []
         
-        if load_time > 2:
-            recommendations.append({
-                "المشكلة": "بطء زمن التحميل",
-                "الحل": "تحسين سرعة الخادم وتفعيل التخزين المؤقت",
-                "الأولوية": "عالية"
-            })
-            
-        if page_size > 1000:
-            recommendations.append({
-                "المشكلة": "حجم الصفحة كبير",
-                "الحل": "ضغط الملفات وتحسين الكود",
-                "الأولوية": "متوسطة"
-            })
-            
-        if image_count > 10:
-            recommendations.append({
-                "المشكلة": "عدد كبير من الصور",
-                "الحل": "تحسين حجم الصور واستخدام التحميل الكسول",
-                "الأولوية": "متوسطة"
-            })
-            
-        if script_count > 5:
-            recommendations.append({
-                "المشكلة": "عدد كبير من ملفات JavaScript",
-                "الحل": "دمج وضغط ملفات JavaScript",
-                "الأولوية": "عالية"
-            })
-            
-        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)
+        for link in links:
+            href = link.get('href', '')
+            if href.startswith('#') or not href:
+                continue
+            elif href.startswith('/') or urlparse(href).netloc == urlparse(href).netloc:
+                internal_links.append(href)
+            else:
+                external_links.append(href)
                 
-                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
-        except Exception as e:
-            return {"error": f"خطأ في تحليل SEO: {str(e)}"}
+            try:
+                response = requests.head(href)
+                if response.status_code >= 400:
+                    broken_links.append(href)
+            except:
+                broken_links.append(href)
+        
+        return {
+            "عدد الروابط الداخلية": len(internal_links),
+            "عدد الروابط الخارجية": len(external_links),
+            "عدد الروابط المكسورة": len(broken_links),
+            "الروابط المكسورة": broken_links
+        }
 
-    def _analyze_content(self, soup):
-        # استخراج النص
-        text_content = ' '.join([p.text for p in soup.find_all('p')])
+   def _analyze_content(self, soup):
+    """
+    Analyzes webpage content for SEO factors
+    """
+    try:
+        # Extract all text content
+        text_content = ' '.join([p.text.strip() for p in soup.find_all(['p', 'div', 'article', 'section'])])
+        
+        # Analyze headings hierarchy
+        headings = {f'h{i}': len(soup.find_all(f'h{i}')) for i in range(1, 7)}
         
-        # تحليل طول المحتوى
-        word_count = len(text_content.split())
+        # Calculate word count
+        words = text_content.split()
+        word_count = len(words)
         
-        # تحليل قراءة المحتوى
+        # Calculate readability score
         readability_score = self._calculate_readability(text_content)
         
-        # تحليل كثافة الكلمات المفتاحية
+        # Analyze keyword density
         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)
+        # Check for images with alt text
+        images = soup.find_all('img')
+        images_with_alt = len([img for img in images if img.get('alt')])
         
-        if total_words == 0:
-            return {}
-            
-        return {word: round((count / total_words) * 100, 2) 
-                for word, count in word_freq.most_common(5)}
-
-   def analyze_security(self, url):
-    try:
-        domain = urlparse(url).netloc
-        whois_info = self._get_whois_info(domain)
+        # Calculate content quality score
+        quality_score = self._calculate_content_quality_score(
+            word_count,
+            readability_score,
+            images_with_alt,
+            len(images),
+            headings
+        )
         
-        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'
-        }
-        
-        results = {}
-        for header, name in security_headers.items():
-            results[name] = {
-                "موجود": header in headers,
-                "القيمة": headers.get(header, "غير موجود")
+            "إحصائيات المحتوى": {
+                "عدد الكلمات": word_count,
+                "مستوى القراءة": readability_score,
+                "نسبة الصور مع نص بديل": f"{(images_with_alt/len(images)*100 if images else 0):.1f}%",
+                "توزيع العناوين": headings,
+            },
+            "تحليل الكلمات المفتاحية": {
+                "كثافة الكلمات الرئيسية": keyword_density,
+                "الكلمات الأكثر تكراراً": self._get_top_words(text_content, 5)
+            },
+            "تقييم جودة المحتوى": {
+                "الدرجة": quality_score,
+                "التقييم": self._get_content_rating(quality_score),
+                "التوصيات": self._get_content_recommendations(
+                    word_count,
+                    readability_score,
+                    images_with_alt,
+                    len(images),
+                    headings
+                )
             }
-        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 "منخفض"
-    }
+        }
+    except Exception as e:
+        return {"error": f"خطأ في تحليل المحتوى: {str(e)}"}
 
-def _calculate_security_score(self, url):
+def _calculate_content_quality_score(self, word_count, readability, alt_images, total_images, headings):
+    """
+    Calculates a content quality score based on various factors
+    """
     score = 100
     
-    # فحص HTTPS
-    if not url.startswith('https'):
-        score -= 30
-    
-    # فحص 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)
-    
+    # Word count scoring
+    if word_count < 300:
+        score -= 20
+    elif word_count < 600:
+        score -= 10
+    
+    # Readability scoring
+    if readability < 40:
+        score -= 15
+    elif readability < 60:
+        score -= 10
+    
+    # Image alt text scoring
+    if total_images > 0:
+        alt_ratio = alt_images / total_images
+        if alt_ratio < 0.5:
+            score -= 15
+        elif alt_ratio < 0.8:
+            score -= 10
+    
+    # Heading hierarchy scoring
+    if headings.get('h1', 0) == 0:
+        score -= 10
+    if headings.get('h1', 0) > 1:
+        score -= 5
+    if headings.get('h2', 0) == 0:
+        score -= 5
+        
     return max(0, score)
 
-def _get_security_recommendations(self, url):
+def _get_content_rating(self, score):
+    """
+    Converts numerical score to qualitative rating
+    """
+    if score >= 90:
+        return "ممتاز"
+    elif score >= 80:
+        return "جيد جداً"
+    elif score >= 70:
+        return "جيد"
+    elif score >= 60:
+        return "مقبول"
+    else:
+        return "يحتاج تحسين"
+
+def _get_content_recommendations(self, word_count, readability, alt_images, total_images, headings):
+    """
+    Generates content improvement recommendations
+    """
     recommendations = []
     
-    # فحص HTTPS
-    if not url.startswith('https'):
+    if word_count < 300:
         recommendations.append({
-            "المشكلة": "عدم استخدام HTTPS",
-            "الحل": "قم بتفعيل HTTPS وتثبيت شهادة SSL",
+            "المشكلة": "محتوى قصير جداً",
+            "الحل": "زيادة المحتوى إلى 300 كلمة على الأقل",
             "الأولوية": "عالية"
         })
     
-    # فحص SSL
-    ssl_info = self._check_ssl(url)
-    if ssl_info.get("الحالة") == "غير آمن ❌":
+    if readability < 60:
+        recommendations.append({
+            "المشكلة": "صعوبة قراءة المحتوى",
+            "الحل": "تبسيط الجمل واستخدام لغة أسهل",
+            "الأولوية": "متوسطة"
+        })
+    
+    if total_images > 0 and (alt_images / total_images) < 0.8:
         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}",
-                    "الأولوية": "متوسطة"
-                })
+    if headings.get('h1', 0) != 1:
+        recommendations.append({
+            "المشكلة": "عدد غير مناسب من عناوين H1",
+            "الحل": "استخدام عنوان H1 واحد فقط للصفحة",
+            "الأولوية": "عالية"
+        })
     
-    return recommendations if recommendations else [
-        {
-            "المشكلة": "لا توجد مشاكل أمنية واضحة",
-            "الحل": "استمر في مراقبة وتحديث إعدادات الأمان",
-            "الأولوية": "منخفضة"
-        }
-    ]
+    return recommendations if recommendations else [{
+        "المشكلة": "لا توجد مشاكل واضحة",
+        "الحل": "الاستمرار في تحديث المحتوى بشكل دوري",
+        "الأولوية": "منخفضة"
+    }]
+
+def _get_top_words(self, text, count=5):
+    """
+    Gets the most frequent meaningful words in the content
+    """
+    # Remove common Arabic and English stop words
+    stop_words = set(['و', 'في', 'من', 'على', 'the', 'and', 'in', 'of', 'to'])
+    words = text.lower().split()
+    word_freq = Counter(word for word in words if word not in stop_words and len(word) > 2)
+    
+    return {word: count for word, count in word_freq.most_common(count)}