Update app.py

app.py

@@ -14,7 +14,7 @@ import whois
 import ssl
 import socket
 import dns.resolver
-from urllib.parse import urlparse
+from urllib.parse import urlparse, urljoin
 import json
 import numpy as np
 from selenium import webdriver
@@ -29,6 +29,10 @@ from fake_useragent import UserAgent
 from concurrent.futures import ThreadPoolExecutor
 import re
 from urllib.robotparser import RobotFileParser
+import random
+from textblob import TextBlob
+from collections import Counter
+import networkx as nx
 
 # تهيئة المتغيرات العامة
 TIMEOUT = 10
@@ -63,7 +67,6 @@ class WebsiteAnalyzer:
 
     async def analyze_performance(self, url):
         try:
-            # قياس سرعة التحميل بشكل واقعي
             performance_metrics = {
                 'dns_lookup': [],
                 'tcp_handshake': [],
@@ -71,640 +74,199 @@ class WebsiteAnalyzer:
                 'content_download': []
             }
 
-            for _ in range(3):  # أخذ متوسط 3 قياسات
+            # تحليل الأداء على أجهزة مختلفة
+            devices = ['desktop', 'mobile', 'tablet']
+            device_metrics = {}
+            
+            for device in devices:
+                chrome_options = Options()
+                chrome_options.add_argument(f"--user-agent={self._get_device_user_agent(device)}")
                 start_time = time.time()
                 
-                # DNS Lookup
+                # قياس الأداء لكل جهاز
+                device_metrics[device] = {
+                    'load_time': time.time() - start_time,
+                    'render_time': self._measure_render_time(url, chrome_options)
+                }
+
+            # تحليل عام للأداء
+            for _ in range(3):
+                start_time = time.time()
                 domain = urlparse(url).netloc
                 dns_start = time.time()
                 socket.gethostbyname(domain)
                 performance_metrics['dns_lookup'].append(time.time() - dns_start)
 
-                # قياس باقي المؤشرات
                 response = await self._fetch_with_retry(url)
-                
                 performance_metrics['ttfb'].append(response.elapsed.total_seconds())
                 performance_metrics['content_download'].append(time.time() - start_time - response.elapsed.total_seconds())
 
-            # حساب المتوسطات
-            avg_metrics = {k: np.mean(v) for k, v in performance_metrics.items()}
-            
-            # تحليل حجم الصفحة ومكوناتها
+            # تحليل الموارد والتحسينات
             soup = BeautifulSoup(response.text, 'html.parser')
-            
-            # تحليل الموارد
-            resources = {
-                'images': len(soup.find_all('img')),
-                'scripts': len(soup.find_all('script')),
-                'stylesheets': len(soup.find_all('link', rel='stylesheet')),
-                'total_size': len(response.content) / 1024  # KB
-            }
-
-            # تقدير حركة المرور باستخدام بيانات من مصادر مختلفة
-            traffic_estimate = await self._estimate_real_traffic(url)
+            resource_analysis = self._analyze_resources(soup, response.content)
+            optimization_suggestions = self._generate_optimization_suggestions(resource_analysis)
 
             return {
                 "أداء الموقع": {
-                    "زمن التحميل الكلي": f"{sum(avg_metrics.values()):.2f} ثانية",
-                    "زمن الاستجابة الأول": f"{avg_metrics['ttfb']:.2f} ثانية",
-                    "تقييم السرعة": self._evaluate_speed(sum(avg_metrics.values())),
-                    "حجم الصفحة": f"{resources['total_size']:.1f} KB"
-                },
-                "تحليل الموارد": {
-                    "عدد الصور": resources['images'],
-                    "عدد ملفات JavaScript": resources['scripts'],
-                    "عدد ملفات CSS": resources['stylesheets']
-                },
-                "إحصائيات الزوار": {
-                    "متوسط الزيارات الشهرية": f"{traffic_estimate:,}",
-                    "تقدير المستخدمين النشطين": f"{int(traffic_estimate * 0.4):,}",
-                    "معدل الارتداد التقريبي": f"{random.randint(35, 65)}%"
-                },
-                "التوصيات": self._generate_performance_recommendations(avg_metrics, resources)
+                    "تحليل الأجهزة": {
+                        device: {
+                            "زمن التحميل": f"{metrics['load_time']:.2f} ثانية",
+                            "زمن العرض": f"{metrics['render_time']:.2f} ثانية"
+                        } for device, metrics in device_metrics.items()
+                    },
+                    "تحليل الموارد": resource_analysis,
+                    "اقتراحات التحسين": optimization_suggestions
+                }
             }
         except Exception as e:
             return {"error": f"حدث خطأ أثناء تحليل الأداء: {str(e)}"}
 
-    async def _estimate_real_traffic(self, url):
-        """تقدير حركة المرور باستخدام مصادر متعددة"""
-        domain = urlparse(url).netloc
-        
-        try:
-            # استخدام بيانات من SimilarWeb API (تحتاج لمفتاح API حقيقي)
-            similar_web_traffic = await self._get_similarweb_data(domain)
-            
-            # استخدام بيانات من Alexa (إذا كانت متوفرة)
-            alexa_rank = await self._get_alexa_rank(domain)
-            
-            # حساب تقدير مركب
-            if similar_web_traffic and alexa_rank:
-                estimated_traffic = (similar_web_traffic + self._rank_to_traffic(alexa_rank)) / 2
-            else:
-                estimated_traffic = similar_web_traffic or self._rank_to_traffic(alexa_rank) or self._estimate_baseline_traffic(domain)
-                
-            return int(estimated_traffic)
-        except:
-            return self._estimate_baseline_traffic(domain)
+    def _analyze_resources(self, soup, content):
+        """تحليل موارد الصفحة وتحديد فرص التحسين"""
+        resources = {
+            'images': self._analyze_images(soup),
+            'scripts': self._analyze_scripts(soup),
+            'styles': self._analyze_styles(soup),
+            'fonts': self._analyze_fonts(soup),
+            'total_size': len(content) / 1024
+        }
+        return resources
 
-    def _estimate_baseline_traffic(self, domain):
-        """تقدير أساسي للحركة بناءً على عمر النطاق وعوامل أخرى"""
-        try:
-            domain_info = whois.whois(domain)
-            domain_age = (datetime.now() - domain_info.creation_date[0]).days if isinstance(domain_info.creation_date, list) else (datetime.now() - domain_info.creation_date).days
-            
-            # معادلة تقريبية تأخذ في الاعتبار عمر النطاق
-            base_traffic = np.random.normal(5000, 1000)  # توزيع طبيعي للحركة الأساسية
-            age_factor = min(domain_age / 365, 5)  # تأثير العمر حتى 5 سنوات
-            
-            estimated_traffic = base_traffic * (1 + age_factor * 0.5)
-            return int(max(500, min(estimated_traffic, 100000)))  # حدود معقولة
-        except:
-            return random.randint(1000, 10000)
+    def _analyze_images(self, soup):
+        """تحليل تفصيلي للصور"""
+        images = soup.find_all('img')
+        return {
+            'count': len(images),
+            'without_alt': len([img for img in images if not img.get('alt')]),
+            'large_images': len([img for img in images if self._is_large_image(img)]),
+            'optimization_needed': self._check_image_optimization(images)
+        }
 
-    async def analyze_seo(self, url):
+    def _analyze_competitors(self, url):
+        """تحليل المنافسين والمقارنة معهم"""
         try:
-            response = await self._fetch_with_retry(url)
-            soup = BeautifulSoup(response.text, 'html.parser')
+            competitors = self._find_competitors(url)
+            comparison = {}
             
-            # تحليل العنوان
-            title = soup.title.string if soup.title else ""
-            title_score = self._analyze_title(title)
-            
-            # تحليل الوصف
-            meta_description = soup.find("meta", {"name": "description"})
-            description = meta_description['content'] if meta_description else ""
-            description_score = self._analyze_description(description)
-            
-            # تحليل الكلمات المفتاحية
-            keywords = self._extract_keywords(soup)
-            
-            # تحليل الروابط
-            internal_links, external_links = self._analyze_links(soup, url)
-            
-            # تحليل المحتوى
-            content_analysis = self._analyze_content(soup)
+            for competitor in competitors:
+                comparison[competitor] = {
+                    'traffic': self._estimate_traffic(competitor),
+                    'keywords': self._analyze_keywords(competitor),
+                    'backlinks': self._analyze_backlinks(competitor),
+                    'social_presence': self._analyze_social_presence(competitor)
+                }
             
             return {
-                "تحليل العناوين": {
-                    "العنوان الرئيسي": title[:60] + "..." if len(title) > 60 else title,
-                    "طول العنوان": len(title),
-                    "تقييم العنوان": title_score['score'],
-                    "التوصيات": title_score['recommendations']
-                },
-                "تحليل الوصف": {
-                    "نص الوصف": description[:100] + "..." if len(description) > 100 else description,
-                    "طول الوصف": len(description),
-                    "تقييم الوصف": description_score['score'],
-                    "التوصيات": description_score['recommendations']
-                },
-                "تحليل الكلمات المفتاحية": {
-                    "الكلمات الرئيسية المكتشفة": keywords[:5],
-                    "كثافة الكلمات المفتاحية": content_analysis['keyword_density'],
-                    "التوصيات": content_analysis['recommendations']
-                },
-                "تحليل الروابط": {
-                    "الروابط الداخلية": len(internal_links),
-                    "الروابط الخارجية": len(external_links),
-                    "نسبة الروابط الداخلية/الخارجية": f"{len(internal_links)/max(len(external_links), 1):.1f}"
-                },
-                "تحليل المحتوى": {
-                    "عدد الكلمات": content_analysis['word_count'],
-                    "تنوع المحتوى": content_analysis['content_diversity'],
-                    "قابلية القراءة": content_analysis['readability']
-                }
+                'المنافسون الرئيسيون': comparison,
+                'تحليل مقارن': self._generate_competitive_analysis(comparison)
             }
         except Exception as e:
-            return {"error": f"حدث خطأ أثناء تحليل SEO: {str(e)}"}
+            return {"error": f"خطأ في تحليل المنافسين: {str(e)}"}
 
-    def _analyze_title(self, title):
-        if not title:
-            return {
-                'score': "0/10",
-                'recommendations': ["يجب إضافة عنوان للصفحة"]
-            }
+    def _analyze_content_quality(self, soup):
+        """تحليل جودة المحتوى"""
+        text_content = soup.get_text()
         
-        score = 10
-        recommendations = []
+        # تحليل لغوي
+        blob = TextBlob(text_content)
+        
+        # تحليل القراءة
+        readability = self._calculate_readability(text_content)
+        
+        # تحليل الكلمات المفتاحية
+        keywords = self._extract_keywords(text_content)
         
-        if len(title) < 30:
-            score -= 2
-            recommendations.append("العنوان قصير جداً، يُفضل أن يكون بين 50-60 حرفاً")
-        elif len(title) > 60:
-            score -= 2
-            recommendations.append("العنوان طويل جداً، يجب تقصيره إلى 60 حرفاً كحد أقصى")
-            
-        if not any(char.isupper() for char in title):
-            score -= 1
-            recommendations.append("استخدم بعض الأحرف الكبيرة في بداية الكلمات المهمة")
-            
         return {
-            'score': f"{score}/10",
-            'recommendations': recommendations
+            "تحليل المحتوى": {
+                "مستوى القراءة": readability,
+                "تنوع المفردات": self._calculate_lexical_diversity(text_content),
+                "الكلمات المفتاحية الرئيسية": keywords[:10],
+                "العاطفة": {
+                    "إيجابية": blob.sentiment.polarity,
+                    "موضوعية": blob.sentiment.subjectivity
+                }
+            }
         }
 
-    def analyze_security(self, url):
+    def _analyze_backlinks(self, url):
+        """تحليل الروابط الخلفية"""
         try:
-            domain = urlparse(url).netloc
-            
-            # فحص شهادة SSL
-            ssl_info = self._check_ssl(domain)
+            backlinks = self._fetch_backlinks(url)
             
-            # فحص سجلات DNS
-            dns_info = self._check_dns(domain)
+            # تحليل جودة الروابط
+            quality_metrics = self._analyze_backlink_quality(backlinks)
             
-            # فحص مستوى الحماية من التهديدات
-            security_headers = self._check_security_headers(url)
-            
-            # فحص معلومات التسجيل
-            registration_info = self._get_domain_info(domain)
+            # تحليل تنوع المصادر
+            diversity = self._analyze_source_diversity(backlinks)
             
             return {
-                "تحليل الأمان": {
-                    "شهادة SSL": ssl_info,
-                    "سجلات DNS": dns_info,
-                    "رؤوس الأمان": security_headers,
-                    "معلومات التسجيل": registration_info,
-                    "درجة الأمان الكلية": self._calculate_security_score(ssl_info, security_headers)
+                "تحليل الروابط الخلفية": {
+                    "العدد الإجمالي": len(backlinks),
+                    "جودة الروابط": quality_metrics,
+                    "تنوع المصادر": diversity,
+                    "أهم المصادر": self._get_top_referring_domains(backlinks)
                 }
             }
         except Exception as e:
-            return {"error": f"حدث خطأ أثناء تحليل الأمان: {str(e)}"}
+            return {"error": f"خطأ في تحليل الروابط الخلفية: {str(e)}"}
 
-    def _check_ssl(self, domain):
+    def _analyze_social_signals(self, url):
+        """تحليل الإشارات الاجتماعية"""
         try:
-            context = ssl.create_default_context()
-            with socket.create_connection((domain, 443)) as sock:
-                with context.wrap_socket(sock, server_hostname=domain) as ssock:
-                    cert = ssock.getpeercert()
-                    
-                    not_after = datetime.strptime(cert['notAfter'], '%b %d %H:%M:%S %Y %Z')
-                    days_left = (not_after - datetime.now()).days
-                    
-                    return {
-                        "الحالة": "✅ آمن" if days_left > 0 else "❌ منتهي",
-                        "نوع الشهادة": cert.get('issuer')[1][0][1],
-                        "تاريخ الانتهاء": not_after.strftime('%Y-%m-%d'),
-                        "الأيام المتبقية": days_left,
-                        "مستوى التشفير": "عالي (TLS 1.3)" if ssl.PROTOCOL_TLSv1_3 else "متوسط (TLS 1.2)"
-                    }
-        except Exception as e:
-            return {
-                "الحالة": "❌ غير آمن",
-                "السبب": str(e)
+            social_metrics = {
+                'facebook': self._get_facebook_shares(url),
+                'twitter': self._get_twitter_shares(url),
+                'linkedin': self._get_linkedin_shares(url),
+                'pinterest': self._get_pinterest_shares(url)
             }
-
-    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'
-            }
+            engagement_analysis = self._analyze_social_engagement(social_metrics)
             
-            results = {}
-            for header, name in security_headers.items
-           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',
-            'Referrer-Policy': 'Referrer Policy',
-            'Permissions-Policy': 'Permissions Policy',
-            'Cross-Origin-Embedder-Policy': 'COEP',
-            'Cross-Origin-Opener-Policy': 'COOP',
-            'Cross-Origin-Resource-Policy': 'CORP'
-        }
-        
-        results = {}
-        score = 100
-        recommendations = []
-        
-        for header, name in security_headers.items():  # Fixed here: added () to items
-            if header in headers:
-                results[name] = {
-                    "موجود": "✅",
-                    "القيمة": headers[header]
-                }
-            else:
-                results[name] = {
-                    "موجود": "❌",
-                    "التوصية": self._get_header_recommendation(header)
+            return {
+                "التواجد الاجتماعي": {
+                    "إحصائيات المشاركة": social_metrics,
+                    "تحليل التفاعل": engagement_analysis,
+                    "توصيات": self._generate_social_recommendations(engagement_analysis)
                 }
-                score -= 10
-                recommendations.append(f"إضافة رأس {name}")
-
-        return {
-            "الرؤوس الموجودة": results,
-            "درجة الأمان": f"{max(score, 0)}/100",
-            "التوصيات": recommendations,
-            "المستوى العام": self._get_security_level(score)
-        }
-    except Exception as e:
-        return {"error": f"خطأ في فحص رؤوس الأمان: {str(e)}"}
-
-    def _get_header_recommendation(self, header):
-        recommendations = {
-            'Strict-Transport-Security': 'max-age=31536000; includeSubDomains',
-            'Content-Security-Policy': "default-src 'self'",
-            'X-Frame-Options': 'SAMEORIGIN',
-            'X-Content-Type-Options': 'nosniff',
-            'X-XSS-Protection': '1; mode=block',
-            'Referrer-Policy': 'strict-origin-when-cross-origin',
-            'Permissions-Policy': 'geolocation=(), microphone=()',
-            'Cross-Origin-Embedder-Policy': 'require-corp',
-            'Cross-Origin-Opener-Policy': 'same-origin',
-            'Cross-Origin-Resource-Policy': 'same-origin'
-        }
-        return recommendations.get(header, 'قيمة موصى بها غير متوفرة')
-
-    def _get_security_level(self, score):
-        if score >= 90:
-            return "ممتاز 🔒"
-        elif score >= 70:
-            return "جيد 🔔"
-        elif score >= 50:
-            return "متوسط ⚠️"
-        else:
-            return "ضعيف ⛔"
-
-    def _check_dns(self, domain):
-        try:
-            results = {
-                "سجلات": {},
-                "توصيات": [],
-                "درجة الأمان": 100
             }
-            
-            # فحص سجلات A
-            try:
-                a_records = dns.resolver.resolve(domain, 'A')
-                results["سجلات"]["A"] = [str(record) for record in a_records]
-            except:
-                results["توصيات"].append("تعذر الوصول لسجلات A")
-                results["درجة الأمان"] -= 20
-
-            # فحص سجلات MX
-            try:
-                mx_records = dns.resolver.resolve(domain, 'MX')
-                results["سجلات"]["MX"] = [str(record.exchange) for record in mx_records]
-            except:
-                results["توصيات"].append("تعذر الوصول لسجلات MX")
-                results["درجة الأمان"] -= 10
-
-            # فحص سجلات TXT
-            try:
-                txt_records = dns.resolver.resolve(domain, 'TXT')
-                results["سجلات"]["TXT"] = [str(record) for record in txt_records]
-                
-                # التحقق من وجود سجلات SPF و DMARC
-                spf_found = any("v=spf1" in str(record) for record in txt_records)
-                dmarc_found = any("v=DMARC1" in str(record) for record in txt_records)
-                
-                if not spf_found:
-                    results["توصيات"].append("إضافة سجل SPF لحماية البريد الإلكتروني")
-                    results["درجة الأمان"] -= 15
-                if not dmarc_found:
-                    results["توصيات"].append("إضافة سجل DMARC لحماية البريد الإلكتروني")
-                    results["درجة الأمان"] -= 15
-                    
-            except:
-                results["توصيات"].append("تعذر الوصول لسجلات TXT")
-                results["درجة الأمان"] -= 10
-
-            # فحص سجلات AAAA (IPv6)
-            try:
-                aaaa_records = dns.resolver.resolve(domain, 'AAAA')
-                results["سجلات"]["AAAA"] = [str(record) for record in aaaa_records]
-            except:
-                results["توصيات"].append("لا يوجد دعم IPv6")
-                results["درجة الأمان"] -= 5
-
-            # إضافة تقييم عام
-            results["التقييم العام"] = self._evaluate_dns_security(results["درجة الأمان"])
-            
-            return results
         except Exception as e:
-            return {"error": f"خطأ في فحص سجلات DNS: {str(e)}"}
-
-    def _evaluate_dns_security(self, score):
-        if score >= 90:
-            return "حماية DNS ممتازة ✅"
-        elif score >= 70:
-            return "حماية DNS جيدة 🔔"
-        elif score >= 50:
-            return "حماية DNS متوسطة ⚠️"
-        else:
-            return "حماية DNS ضعيفة ⛔"
+            return {"error": f"خطأ في تحليل الإشارات الاجتماعية: {str(e)}"}
 
-    def _get_domain_info(self, domain):
+    def _generate_comprehensive_report(self, url):
+        """توليد تقرير شامل"""
         try:
-            domain_info = whois.whois(domain)
-            
-            # تحويل التواريخ إلى صيغة مقروءة
-            creation_date = domain_info.creation_date
-            expiration_date = domain_info.expiration_date
-            
-            if isinstance(creation_date, list):
-                creation_date = creation_date[0]
-            if isinstance(expiration_date, list):
-                expiration_date = expiration_date[0]
-
-            # حساب عمر النطاق
-            domain_age = (datetime.now() - creation_date).days if creation_date else None
-            days_to_expiry = (expiration_date - datetime.now()).days if expiration_date else None
-
-            return {
-                "معلومات التسجيل": {
-                    "اسم النطاق": domain,
-                    "تاريخ التسجيل": creation_date.strftime('%Y-%m-%d') if creation_date else "غير متوفر",
-                    "تاريخ الانتهاء": expiration_date.strftime('%Y-%m-%d') if expiration_date else "غير متوفر",
-                    "عمر النطاق": f"{domain_age} يوم" if domain_age else "غير متوفر",
-                    "الأيام المتبقية للانتهاء": f"{days_to_expiry} يوم" if days_to_expiry else "غير متوفر",
-                    "المسجل": domain_info.registrar or "غير متوفر",
-                    "الحالة": domain_info.status if isinstance(domain_info.status, list) else [domain_info.status] if domain_info.status else []
-                },
-                "تقييم الموثوقية": self._evaluate_domain_trust(domain_age if domain_age else 0, domain_info)
+            report = {
+                "تحليل الأداء": self.analyze_performance(url),
+                "تحليل SEO": self.analyze_seo(url),
+                "تحليل الأمان": self.analyze_security(url),
+                "تحليل المنافسين": self._analyze_competitors(url),
+                "تحليل المحتوى": self._analyze_content_quality(BeautifulSoup(requests.get(url).text, 'html.parser')),
+                "تحليل الروابط": self._analyze_backlinks(url),
+                "التواجد الاجتماعي": self._analyze_social_signals(url),
+                "التوصيات": self._generate_recommendations()
             }
+            
+            return report
         except Exception as e:
-            return {"error": f"خطأ في جلب معلومات النطاق: {str(e)}"}
-
-    def _evaluate_domain_trust(self, age_days, domain_info):
-        trust_score = 0
-        reasons = []
-        
-        # تقييم العمر
-        if age_days > 365*5:  # أكثر من 5 سنوات
-            trust_score += 40
-            reasons.append("نطاق قديم وموثوق")
-        elif age_days > 365:  # أكثر من سنة
-            trust_score += 25
-            reasons.append("نطاق مستقر")
-        else:
-            trust_score += 10
-            reasons.append("نطاق حديث")
-
-        # تقييم المسجل
-        if domain_info.registrar and any(trusted in domain_info.registrar.lower() for trusted in ['godaddy', 'namecheap', 'name.com', 'google']):
-            trust_score += 20
-            reasons.append("مسجل موثوق")
+            return {"error": f"خطأ في توليد التقرير الشامل: {str(e)}"}
 
-        # تقييم الحالة
-        if domain_info.status:
-            statuses = domain_info.status if isinstance(domain_info.status, list) else [domain_info.status]
-            if 'clientTransferProhibited' in statuses:
-                trust_score += 20
-                reasons.append("محمي من النقل غير المصرح به")
-            if 'clientDeleteProhibited' in statuses:
-                trust_score += 20
-                reasons.append("محمي من الحذف غير المصرح به")
-
-        return {
-            "درجة الموثوقية": f"{trust_score}/100",
-            "المستوى": self._get_trust_level(trust_score),
-            "الأسباب": reasons
-        }
-
-    def _get_trust_level(self, score):
-        if score >= 80:
-            return "موثوق جداً 🌟"
-        elif score >= 60:
-            return "موثوق ✅"
-        elif score >= 40:
-            return "موثوقية متوسطة ⚠️"
-        else:
-            return "موثوقية منخفضة ⛔"
-            def _analyze_seo(self, url):
-    try:
-        response = requests.get(url)
-        soup = BeautifulSoup(response.text, 'html.parser')
-        
-        results = {
-            "العناصر الأساسية": {},
-            "الوسوم الوصفية": {},
-            "توصيات": [],
-            "درجة SEO": 100
-        }
-        
-        # فحص العنوان
-        title = soup.find('title')
-        if title and title.text.strip():
-            title_length = len(title.text.strip())
-            results["العناصر الأساسية"]["العنوان"] = {
-                "القيمة": title.text.strip(),
-                "الطول": title_length,
-                "التقييم": "✅" if 30 <= title_length <= 60 else "⚠️"
-            }
-            if title_length < 30 or title_length > 60:
-                results["توصيات"].append("تعديل طول العنوان ليكون بين 30-60 حرف")
-                results["درجة SEO"] -= 10
-        else:
-            results["العناصر الأساسية"]["العنوان"] = {"القيمة": "غير موجود", "التقييم": "❌"}
-            results["توصيات"].append("إضافة عنوان للصفحة")
-            results["درجة SEO"] -= 20
-        
-        # فحص الوصف
-        meta_desc = soup.find('meta', attrs={'name': 'description'})
-        if meta_desc and meta_desc.get('content', '').strip():
-            desc_length = len(meta_desc['content'].strip())
-            results["الوسوم الوصفية"]["الوصف"] = {
-                "القيمة": meta_desc['content'].strip(),
-                "الطول": desc_length,
-                "التقييم": "✅" if 120 <= desc_length <= 160 else "⚠️"
-            }
-            if desc_length < 120 or desc_length > 160:
-                results["توصيات"].append("تعديل طول الوصف ليكون بين 120-160 حرف")
-                results["درجة SEO"] -= 10
-        else:
-            results["الوسوم الوصفية"]["الوصف"] = {"القيمة": "غير موجود", "التقييم": "❌"}
-            results["توصيات"].append("إضافة وصف للصفحة")
-            results["درجة SEO"] -= 15
-        
-        # فحص الكلمات المفتاحية
-        keywords = soup.find('meta', attrs={'name': 'keywords'})
-        results["الوسوم الوصفية"]["الكلمات المفتاحية"] = {
-            "القيمة": keywords['content'].strip() if keywords else "غير موجود",
-            "التقييم": "✅" if keywords else "ℹ️"
-        }
-        
-        # فحص العناوين الفرعية
-        headings = {f"h{i}": len(soup.find_all(f'h{i}')) for i in range(1, 7)}
-        results["العناصر الأساسية"]["العناوين الفرعية"] = headings
-        if not headings.get('h1'):
-            results["توصيات"].append("إضافة عنوان رئيسي H1")
-            results["درجة SEO"] -= 15
-        elif headings.get('h1') > 1:
-            results["توصيات"].append("يجب أن يكون هناك عنوان H1 واحد فقط")
-            results["درجة SEO"] -= 10
-        
-        # فحص الصور
-        images = soup.find_all('img')
-        missing_alt = sum(1 for img in images if not img.get('alt'))
-        results["العناصر الأساسية"]["الصور"] = {
-            "العدد الإجمالي": len(images),
-            "بدون نص بديل": missing_alt
-        }
-        if missing_alt:
-            results["توصيات"].append(f"إضافة نص بديل لـ {missing_alt} صورة")
-            results["درجة SEO"] -= min(15, missing_alt * 2)
-        
-        # تقييم عام
-        results["التقييم العام"] = self._get_seo_level(results["درجة SEO"])
-        
-        return results
-    except Exception as e:
-        return {"error": f"خطأ في تحليل SEO: {str(e)}"}
-
-def _get_seo_level(self, score):
-    if score >= 90:
-        return "ممتاز 🌟"
-    elif score >= 70:
-        return "جيد ✅"
-    elif score >= 50:
-        return "متوسط ⚠️"
-    else:
-        return "ضعيف ⛔"
-
-def _analyze_performance(self, url):
-    try:
-        start_time = time.time()
-        response = requests.get(url)
-        load_time = time.time() - start_time
-        
-        results = {
-            "مقاييس الأداء": {},
-            "تحليل المحتوى": {},
-            "توصيات": [],
-            "درجة الأداء": 100
-        }
-        
-        # قياس زمن التحميل
-        results["مقاييس الأداء"]["زمن التحميل"] = {
-            "القيمة": f"{load_time:.2f} ثانية",
-            "التقييم": "✅" if load_time < 2 else "⚠️" if load_time < 4 else "❌"
-        }
-        if load_time >= 2:
-            results["توصيات"].append("تحسين زمن تحميل الصفحة")
-            results["درجة الأداء"] -= min(30, int(load_time * 10))
-        
-        # تحليل حجم الصفحة
-        page_size = len(response.content) / 1024  # تحويل إلى كيلوبايت
-        results["مقاييس الأداء"]["حجم الصفحة"] = {
-            "القيمة": f"{page_size:.2f} KB",
-            "التقييم": "✅" if page_size < 500 else "⚠️" if page_size < 1000 else "❌"
-        }
-        if page_size >= 500:
-            results["توصيات"].append("تقليل حجم الصفحة")
-            results["درجة الأداء"] -= min(20, int(page_size/100))
-        
-        # تحليل المحتوى
-        soup = BeautifulSoup(response.text, 'html.parser')
-        
-        # عدد ملفات JavaScript
-        scripts = soup.find_all('script')
-        results["تحليل المحتوى"]["ملفات JavaScript"] = {
-            "العدد": len(scripts),
-            "التقييم": "✅" if len(scripts) < 10 else "⚠️" if len(scripts) < 15 else "❌"
-        }
-        if len(scripts) >= 10:
-            results["توصيات"].append("تقليل عدد ملفات JavaScript")
-            results["درجة الأداء"] -= min(15, len(scripts))
-        
-        # عدد ملفات CSS
-        css_files = soup.find_all('link', rel='stylesheet')
-        results["تحليل المحتوى"]["ملفات CSS"] = {
-            "العدد": len(css_files),
-            "التقييم": "✅" if len(css_files) < 5 else "⚠️" if len(css_files) < 8 else "❌"
-        }
-        if len(css_files) >= 5:
-            results["توصيات"].append("تقليل عدد ملفات CSS")
-            results["درجة الأداء"] -= min(10, len(css_files) * 2)
-        
-        # عدد الصور وحجمها
-        images = soup.find_all('img')
-        total_images_size = 0
-        for img in images:
-            if img.get('src'):
-                try:
-                    img_response = requests.head(urljoin(url, img['src']))
-                    total_images_size += int(img_response.headers.get('content-length', 0))
-                except:
-                    continue
-        
-        total_images_size_kb = total_images_size / 1024
-        results["تحليل المحتوى"]["الصور"] = {
-            "العدد": len(images),
-            "الحجم الإجمالي": f"{total_images_size_kb:.2f} KB",
-            "التقييم": "✅" if total_images_size_kb < 1000 else "⚠️" if total_images_size_kb < 2000 else "❌"
+    def _generate_recommendations(self):
+        """توليد توصيات مخصصة"""
+        recommendations = {
+            "تحسينات عاجلة": [],
+            "تحسينات متوسطة الأولوية": [],
+            "تحسينات طويلة المدى": []
         }
         
-        if total_images_size_kb >= 1000:
-            results["توصيات"].append("ضغط الصور وتحسين حجمها")
-            results["درجة الأداء"] -= min(15, int(total_images_size_kb/200))
-        
-        # تقييم عام
-        results["التقييم العام"] = self._get_performance_level(results["درجة الأداء"])
-        
-        return results
-    except Exception as e:
-        return {"error": f"خطأ في تحليل الأداء: {str(e)}"}
-
-def _get_performance_level(self, score):
-    if score >= 90:
-        return "أداء ممتاز 🚀"
-    elif score >= 70:
-        return "أداء جيد ✅"
-    elif score >= 50:
-        return "أداء متوسط ⚠️"
-    else:
-        return "أداء ضعيف ⛔"
+        # إضافة التوصيات بناءً على نتائج التحليل
+        return recommendations
+
+# مثال للاستخدام
+async def main():
+    analyzer = WebsiteAnalyzer()
+    url = "https://example.com"
+    report = await analyzer._generate_comprehensive_report(url)
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+
+if __name__ == "__main__":
+    asyncio.run(main())