app.py

import gradio as gr
import os
import time
import json
import re
import smtplib
import requests
import random
import threading
import hashlib
from datetime import datetime, timedelta
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.utils import formataddr, make_msgid
from openai import OpenAI
from apscheduler.schedulers.background import BackgroundScheduler
from upstash_redis import Redis as UpstashRedis

os.environ["TZ"] = "UTC"

# ==========================================
# 1. إعدادات البيئة والمفاتيح
# ==========================================

NVIDIA_API_KEY       = os.getenv("NVIDIA_API_KEY")
GITHUB_TOKEN         = os.getenv("GITHUB_TOKEN")
# Reddit — Cookies من state.json (لا يحتاج API أو Client ID)
# Reddit OAuth — يحتاج: REDDIT_CLIENT_ID, REDDIT_CLIENT_SECRET, REDDIT_USERNAME, REDDIT_PASSWORD
# اذهب لـ reddit.com/prefs/apps → Create App → script → احصل على ID و Secret
REDDIT_CLIENT_ID     = os.getenv("REDDIT_CLIENT_ID",     "")
REDDIT_CLIENT_SECRET = os.getenv("REDDIT_CLIENT_SECRET", "")
REDDIT_USERNAME      = os.getenv("REDDIT_USERNAME",      "")
REDDIT_PASSWORD      = os.getenv("REDDIT_PASSWORD",      "")
SMTP_EMAIL           = os.getenv("SMTP_EMAIL")
SMTP_PASSWORD        = os.getenv("SMTP_PASSWORD")
DEVTO_API_KEY        = os.getenv("DEVTO_API_KEY")           # اختياري
DISCORD_BOT_TOKEN    = os.getenv("DISCORD_BOT_TOKEN")       # اختياري
# DISCORD_GUILD_IDS لم يعد مطلوباً — السيرفرات تُكتشف تلقائياً
# ── اكتشاف SMTP تلقائي بناءً على دومين الإيميل ──────────────────────────
# Namecheap:  mail.yourdomain.com  port 587  (كلمة المرور العادية مباشرة)
# Gmail:      smtp.gmail.com       port 587  (يحتاج App Password)
# Outlook:    smtp.office365.com   port 587
def _detect_smtp(email: str) -> tuple:
    if not email:
        return "smtp.gmail.com", 587
    domain = email.split("@")[-1].lower()
    TABLE = {
        "gmail.com":       ("smtp.gmail.com",        587),
        "googlemail.com":  ("smtp.gmail.com",        587),
        "outlook.com":     ("smtp.office365.com",    587),
        "hotmail.com":     ("smtp.office365.com",    587),
        "live.com":        ("smtp.office365.com",    587),
        "yahoo.com":       ("smtp.mail.yahoo.com",   587),
        "icloud.com":      ("smtp.mail.me.com",      587),
        "protonmail.com":  ("smtp.protonmail.com",   587),
        "zoho.com":        ("smtp.zoho.com",         587),
        "zohomail.com":    ("smtp.zoho.com",         587),
    }
    if domain in TABLE:
        return TABLE[domain]
    # دومين خاص — Namecheap / cPanel / Hostinger / SiteGround
    return f"mail.{domain}", 587

SMTP_SERVER, SMTP_PORT = _detect_smtp(SMTP_EMAIL)
print(f"📧 SMTP auto-detected: {SMTP_SERVER}:{SMTP_PORT}")

SITE_URL = "https://www.orgteh.com"

UPSTASH_REDIS_REST_URL   = os.getenv("UPSTASH_REDIS_REST_URL")
UPSTASH_REDIS_REST_TOKEN = os.getenv("UPSTASH_REDIS_REST_TOKEN")

# حدود يومية — موزعة لتصل المجموع 1000-10000/يوم
# Email: الأعلى لأن الإيميل مدفوع وآمن
# GitHub: متوسط مع فلتر صارم للمبتدئين
# Reddit/Dev.to/Discord: محافظة نسبياً لتجنب الحظر
LIMITS = {
    "email_daily":    5000,   # إيميل مدفوع → حجم كبير
    "github_daily":   3000,   # Issues كثيرة لكن فلتر صارم
    "reddit_daily":    300,   # Reddit حساس → متوسط
    "devto_daily":     500,   # Dev.to أكثر تسامحاً
    "stackoverflow_daily": 500,
    "producthunt_daily":   200,
    "discord_daily":   200,
}

# ==========================================
# 2. نظام الذاكرة الحديدية (Iron Memory)
# ==========================================

class IronMemory:
    """
    يحفظ كل URL / معرف مستخدم تم التعامل معه بشكل دائم.
    يعمل على طبقتين: ذاكرة محلية (سريعة) + Upstash Redis (سحابية / دائمة).
    لن نعود لأي شخص أو رابط تم حفظه أبداً حتى بعد إعادة التشغيل.
    """
    SET_KEY  = "orgteh:processed"
    LOGS_KEY = "orgteh:logs"
    USERS_KEY = "orgteh:users"        # مجموعة معرفات المستخدمين تحديداً

    def __init__(self):
        self._local: set = set()
        self._users: set = set()
        self.redis = None
        self.enabled = False
        if UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN:
            try:
                self.redis = UpstashRedis(url=UPSTASH_REDIS_REST_URL, token=UPSTASH_REDIS_REST_TOKEN)
                self.redis.ping()
                self.enabled = True
                print("✅ Iron Memory: Upstash Redis متصل — الذاكرة الدائمة نشطة")
            except Exception as e:
                print(f"❌ Upstash خطأ: {e} — سيعمل النظام بذاكرة مؤقتة فقط")
        else:
            print("⚠️ بيانات Upstash غير موجودة — الذاكرة مؤقتة فقط")

    # --- فحص ---
    def seen(self, key: str) -> bool:
        if key in self._local:
            return True
        if self.enabled:
            try:
                return bool(self.redis.sismember(self.SET_KEY, key))
            except:
                pass
        return False

    def user_seen(self, user_id: str) -> bool:
        if user_id in self._users:
            return True
        if self.enabled:
            try:
                return bool(self.redis.sismember(self.USERS_KEY, user_id))
            except:
                pass
        return False

    # --- تسجيل ---
    def mark(self, key: str):
        self._local.add(key)
        if self.enabled:
            try:
                self.redis.sadd(self.SET_KEY, key)
            except:
                pass

    def mark_user(self, user_id: str):
        self._users.add(user_id)
        if self.enabled:
            try:
                self.redis.sadd(self.USERS_KEY, user_id)
            except:
                pass

    # --- السجلات ---
    def log(self, platform, title, url, snippet, reply):
        entry = {
            "ts":       datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "platform": platform,
            "title":    title,
            "url":      url,
            "snippet":  (snippet or "")[:400],
            "reply":    reply,
        }
        LOCAL_LOGS.insert(0, entry)
        if len(LOCAL_LOGS) > 200:
            LOCAL_LOGS.pop()
        if self.enabled:
            try:
                self.redis.lpush(self.LOGS_KEY, json.dumps(entry, ensure_ascii=False))
                self.redis.ltrim(self.LOGS_KEY, 0, 499)
            except:
                pass
        return entry

    def load_logs(self):
        """يجلب السجل من Redis أو الذاكرة المحلية."""
        if self.enabled:
            try:
                raw = self.redis.lrange(self.LOGS_KEY, 0, 99)
                result = []
                for item in raw:
                    try:
                        # upstash-redis قد يرجع string أو dict مباشرة
                        if isinstance(item, dict):
                            result.append(item)
                        elif isinstance(item, (str, bytes)):
                            result.append(json.loads(item))
                    except:
                        pass
                if result:
                    return result
            except Exception as e:
                print(f"  load_logs Redis error: {e}")
        return LOCAL_LOGS[:]

    def save_stats(self, stats: dict):
        """يحفظ الإحصائيات اليومية في Redis."""
        if self.enabled:
            try:
                today = datetime.utcnow().strftime("%Y-%m-%d")
                self.redis.set(f"orgteh:stats:{today}", json.dumps(stats))
            except:
                pass

    def load_stats(self) -> dict:
        """يجلب إحصائيات اليوم من Redis."""
        if self.enabled:
            try:
                today = datetime.utcnow().strftime("%Y-%m-%d")
                raw = self.redis.get(f"orgteh:stats:{today}")
                if raw:
                    if isinstance(raw, dict):
                        return raw
                    return json.loads(raw)
            except:
                pass
        return {}


memory = IronMemory()
LOCAL_LOGS = []
LOCAL_STATS = {
    "reddit": 0, "github": 0, "email": 0,
    "devto": 0, "stackoverflow": 0, "producthunt": 0, "discord": 0,
    "emails_found": 0, "emails_queued": 0, "emails_sent": 0,
    "replies_received": 0,
}

# ==========================================
# سجل النشاط التفصيلي (لكل عملية بحث)
# ==========================================
ACTIVITY_LOGS: list = []      # بحث، إيميلات وُجدت، تعليقات أُرسلت
SENT_EMAILS_LOG: list = []    # سجل الإيميلات المرسلة
REPLIES_LOG: list = []        # ردود المستخدمين على تعليقاتنا
_activity_lock = threading.Lock()

# جمع معرفات تعليقاتنا لمتابعة الردود عليها
_our_github_comments: list = []   # [(repo_api_url, comment_id, title), ...]
_our_reddit_comments: list = []   # [(post_url, comment_fullname, title), ...]
_our_comments_lock = threading.Lock()


def log_activity(platform: str, action: str, site: str,
                 found: int = 0, note: str = "", level: str = "info"):
    """
    يسجّل نشاطاً تفصيلياً لعملية بحث أو إرسال.
    level: info | success | warn | error
    """
    icon_map = {
        "info":    "🔎",
        "success": "✅",
        "warn":    "⚠️",
        "error":   "❌",
    }
    entry = {
        "ts":       datetime.now().strftime("%H:%M:%S"),
        "platform": platform,
        "action":   action,
        "site":     site,
        "found":    found,
        "note":     note,
        "level":    level,
        "icon":     icon_map.get(level, "🔎"),
    }
    with _activity_lock:
        ACTIVITY_LOGS.insert(0, entry)
        if len(ACTIVITY_LOGS) > 600:
            ACTIVITY_LOGS.pop()


def log_sent_email(to: str, subject: str, body: str, url: str, title: str):
    entry = {
        "ts":      datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        "to":      to,
        "subject": subject,
        "body":    body[:300],
        "url":     url,
        "title":   title,
    }
    with _activity_lock:
        SENT_EMAILS_LOG.insert(0, entry)
        if len(SENT_EMAILS_LOG) > 300:
            SENT_EMAILS_LOG.pop()


def log_reply(platform: str, from_user: str, our_content: str,
              their_reply: str, url: str):
    entry = {
        "ts":          datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        "platform":    platform,
        "from_user":   from_user,
        "our_content": our_content[:200],
        "their_reply": their_reply[:400],
        "url":         url,
    }
    with _activity_lock:
        REPLIES_LOG.insert(0, entry)
        if len(REPLIES_LOG) > 200:
            REPLIES_LOG.pop()
    LOCAL_STATS["replies_received"] = LOCAL_STATS.get("replies_received", 0) + 1

# ==========================================
# 3. محرك الذكاء الاصطناعي
# ==========================================

client = OpenAI(base_url="https://integrate.api.nvidia.com/v1", api_key=NVIDIA_API_KEY)

def ask_ai(prompt: str, system: str = "You are a helpful assistant.", temp=0.5) -> str | None:
    try:
        resp = client.chat.completions.create(
            model="meta/llama-3.3-70b-instruct",
            messages=[{"role": "system", "content": system}, {"role": "user", "content": prompt}],
            temperature=temp, max_tokens=900
        )
        return resp.choices[0].message.content.strip()
    except Exception as e:
        print(f"AI Error: {e}")
        return None

# ==========================================
# 4. نظام كلمات البحث الذكي — تلقائي 100%
# ==========================================
# طبقتان:
#   1. FALLBACK_KEYWORDS  — كلمات ثابتة لضمان العمل دائماً
#   2. كل KEYWORD_REFRESH_MINUTES يطلب النموذج توليد كلمات جديدة بنفسه
#      بكل اللغات الممكنة بناءً على ما يعرفه عن Orgteh وسوق AI API

# ── كلمات ثابتة (Fallback) — جمهوران: مطورو AI API + أصحاب المواقع ──
FALLBACK_KEYWORDS: list[str] = [

    # ════ جمهور 1: مطورو AI API ════

    # EN — API developers
    "llm api", "ai api", "chatbot api", "language model api",
    "integrate llm", "openai api", "deepseek api", "mistral api",
    "llama api", "chat completions api", "ai api developer",
    "openai api alternative", "cheap llm api",

    # AR — مطورو API (عربي — أولوية عالية)
    "api ذكاء اصطناعي", "واجهة برمجية نموذج لغوي", "دمج نموذج ذكاء اصطناعي",
    "api للنماذج اللغوية", "بناء تطبيق ذكاء اصطناعي api",
    "كيف أستخدم api الذكاء الاصطناعي", "نموذج لغوي api",
    "بديل openai رخيص", "api ذكاء اصطناعي مجاني",

    # TR / FR / ES / DE / PT / RU / ZH / JA / KO / HI / ID
    "yapay zeka api", "llm api entegrasyonu",
    "api intelligence artificielle", "intégrer llm api",
    "api inteligencia artificial", "integrar llm api",
    "ki api", "sprachmodell api",
    "api inteligência artificial", "chatbot api integração",
    "языковая модель api", "llm api интеграция",
    "大语言模型 api", "ai api 接入",
    "llm api 統合", "言語モデル api",
    "llm api 통합", "챗봇 api 연동",
    "ai api इंटीग्रेशन", "chatbot api developer",

    # ════ جمهور 2: أصحاب المواقع — chatbot / خدمة عملاء ════

    # EN — website owners / customer service
    "add chatbot to website",
    "ai customer service chatbot",
    "chatbot for my website",
    "automated customer support",
    "ai support widget",
    "customer service automation",
    "embed chatbot website",
    "ai chat widget",
    "24/7 customer support ai",
    "chatbot ecommerce store",
    "automate customer questions",
    "website chatbot no code",
    "ai answers customer questions",
    "chatbot for small business",
    "install chatbot website",

    # AR — أصحاب المواقع / خدمة العملاء (عربي — أولوية عالية)
    "إضافة شات بوت للموقع",
    "روبوت محادثة لخدمة العملاء",
    "اتمتة خدمة العملاء",
    "شات بوت لموقعي",
    "مساعد ذكي للموقع",
    "خدمة عملاء آلية",
    "ويدجيت شات بوت عربي",
    "روبوت محادثة للمتجر الإلكتروني",
    "كيف أضيف شات بوت لموقعي",
    "أتمتة الردود على العملاء",
    "بوت خدمة عملاء للموقع",
    "شات بوت لمتجر سلة زيد",
    "دعم عملاء تلقائي",

    # TR
    "web sitesine chatbot ekle", "müşteri hizmetleri botu",
    "otomatik müşteri desteği",
    # FR
    "chatbot service client", "ajouter chatbot site web",
    "support client automatisé",
    # ES
    "chatbot atención al cliente", "añadir chatbot sitio web",
    "soporte cliente automatizado",
    # DE
    "chatbot kundendienst", "chatbot website einbinden",
    "automatischer kundensupport",
    # PT
    "chatbot atendimento cliente", "adicionar chatbot site",
    # RU
    "чатбот служба поддержки", "добавить чатбот сайт",
    # ZH
    "网站添加聊天机器人", "客服聊天机器人",
    # ID
    "chatbot layanan pelanggan", "tambah chatbot ke website",
]

KEYWORD_REFRESH_MINUTES = 90   # كل 90 دقيقة يطلب كلمات جديدة
_keyword_cache: list[str] = list(FALLBACK_KEYWORDS)
_last_keyword_refresh: float = 0.0
_keyword_lock = threading.Lock()


def _ai_generate_keywords() -> list[str]:
    """
    يطلب من النموذج توليد كلمات بحث لجمهورين:
    1. مطورون يريدون AI API
    2. أصحاب مواقع يريدون chatbot / widget لخدمة العملاء
    بكل اللغات الممكنة — خاصة العربية.
    """
    prompt = """You are marketing Orgteh (orgteh.com) which has TWO products:
1. AI API for developers (OpenAI-compatible, cheap, multiple models)
2. AI Customer Service Widget — embed a chatbot on any website in minutes, reads site content automatically (RAG)

Generate 60 short search keywords (2-5 words) to find BOTH audiences across the internet.

TARGET AUDIENCE 1 — Developers:
- Want to USE an AI/LLM API for projects
- Building chatbots, apps, integrations
- Looking for cheaper OpenAI alternatives

TARGET AUDIENCE 2 — Website/Business Owners:
- Want to add a chatbot to their website
- Need automated customer service / support
- E-commerce, SaaS, service businesses
- May not be technical — want a simple widget

LANGUAGE COVERAGE (this is critical):
- Arabic (عربي) — HIGH PRIORITY, include at least 15 Arabic keywords
- English — HIGH PRIORITY
- Turkish, French, Spanish, German, Portuguese, Russian, Chinese, Japanese, Korean, Indonesian, Hindi

RULES:
- Keywords must be SHORT and natural (how people actually search)
- Mix both audiences proportionally
- Arabic keywords should sound natural, not machine-translated
- Output ONLY a JSON array, no explanation:
["keyword1", "keyword2", ...]"""

    resp = ask_ai(prompt, temp=0.8)
    if resp:
        try:
            m = re.search(r'\[.*\]', resp, re.DOTALL)
            if m:
                keywords = json.loads(m.group(0))
                valid = [k.strip() for k in keywords if isinstance(k, str) and 2 < len(k.strip()) < 60]
                if len(valid) >= 10:
                    print(f"🔄 Keywords refreshed: {len(valid)} new keywords generated by AI")
                    return valid
        except Exception as e:
            print(f"Keyword generation parse error: {e}")
    return []


def refresh_keywords_if_needed():
    """يجدد كلمات البحث تلقائياً كل KEYWORD_REFRESH_MINUTES."""
    global _keyword_cache, _last_keyword_refresh
    now = time.time()
    with _keyword_lock:
        if now - _last_keyword_refresh > KEYWORD_REFRESH_MINUTES * 60:
            new_kws = _ai_generate_keywords()
            if new_kws:
                # نمزج الكلمات الجديدة مع الثابتة لضمان التغطية
                _keyword_cache = list(set(FALLBACK_KEYWORDS + new_kws))
                _last_keyword_refresh = now


def _keyword_refresh_loop():
    """خيط مستقل يجدد الكلمات بشكل دوري."""
    # توليد فوري عند البدء
    refresh_keywords_if_needed()
    while True:
        time.sleep(KEYWORD_REFRESH_MINUTES * 60)
        refresh_keywords_if_needed()


def get_random_keywords(n: int = 3) -> list[str]:
    """يختار n كلمات عشوائية من الكاش الحالي (ثابتة + مولّدة)."""
    with _keyword_lock:
        pool = _keyword_cache if _keyword_cache else FALLBACK_KEYWORDS
    return random.sample(pool, min(n, len(pool)))

# ==========================================
# 5. مولّد الردود الذكي
# ==========================================

# ══ وصف الخدمتين اللتين نسوّق لهما ══
SITE_CONTEXT = """
Orgteh (orgteh.com) offers TWO main products:

PRODUCT 1 — AI API for Developers:
- OpenAI-compatible endpoint: https://orgteh.com/v1/chat/completions
- Multiple models: DeepSeek-R1, Kimi (256K context), Mistral, Llama-3B, Gemma
- API keys start with "Orgteh_"
- GPU-accelerated, sub-second response, enterprise security, streaming
- Drop-in replacement for OpenAI (zero code changes)
- Registration: orgteh.com/register

PRODUCT 2 — AI Customer Service Widget (NEW):
- A ready-made chatbot widget you embed on ANY website in minutes (one script tag)
- The AI reads YOUR website content automatically (RAG — no manual training needed)
- Answers customer questions 24/7 in any language based on your own content
- Perfect for: e-commerce stores, SaaS products, service businesses, startups
- No coding required — just paste the script and it works
- orgteh.com/widget
"""

# أي منتج نروّج له بناءً على من نتحدث معه
AUDIENCE_API    = "api_developer"      # مطور يريد استخدام AI API
AUDIENCE_WIDGET = "website_owner"     # صاحب موقع يريد chatbot لخدمة العملاء

REPLY_STYLES = [
    "casual_developer",   # مطور يشارك تجربته
    "helpful_peer",       # زميل يساعد
    "been_there",         # شخص مر بنفس المشكلة
]

def ai_judge(text: str) -> str | None:
    """
    فلتر صارم — يرفض أي شيء غير مرتبط مباشرة بمنتجاتنا.
    يرجع: "api_developer" | "website_owner" | None
    """
    prompt = (
        "Read this text carefully:\n"
        "---\n"
        + text[:500] +
        "\n---\n\n"
        "Does this person have an ACTIVE, CONCRETE need for one of these:\n"
        "  API_DEVELOPER: They are RIGHT NOW trying to USE or INTEGRATE an AI/LLM API "
        "in a real project they are building. They need API access, keys, endpoints, or a cheaper alternative.\n"
        "  WEBSITE_OWNER: They RIGHT NOW want to ADD a chatbot/AI assistant to their website "
        "for customer service, support automation, or answering visitor questions.\n"
        "  NONE: Everything else — bugs in other software, general AI discussion, "
        "account/billing issues, feature requests for other products, research, news.\n\n"
        "STRICT RULES:\n"
        "- Bug reports about OTHER software = NONE\n"
        "- Account/billing/verification issues = NONE\n"
        "- General AI news or opinions = NONE\n"
        "- Contributing to open source AI projects = NONE\n"
        "- Only classify as API_DEVELOPER or WEBSITE_OWNER if the need is DIRECT and IMMEDIATE\n\n"
        "Answer ONE word only: API_DEVELOPER, WEBSITE_OWNER, or NONE\nAnswer:"
    )
    resp = ask_ai(prompt, temp=0.0)
    if not resp:
        return None
    r = resp.strip().upper()
    if r.startswith("API_DEVELOPER"):
        return AUDIENCE_API
    if r.startswith("WEBSITE_OWNER"):
        return AUDIENCE_WIDGET
    return None


def ai_judge_github(text: str, repo: str = "") -> bool:
    """
    فلتر GitHub إضافي — يرفض:
    - مستودعات مشاريع AI كبيرة (LibreChat, Ollama, LangChain...)
    - Issues تقنية عميقة (bugs, architecture, performance)
    - أي شيء لا يطلب فيه الشخص API جاهز للاستخدام
    """
    # رفض سريع للمستودعات المعروفة
    BLOCKED_REPOS = [
        "anthropic", "openai", "microsoft", "google", "meta-llama",
        "ollama", "librechat", "langchain", "huggingface", "mistralai",
        "deepseek", "cohere", "stability-ai", "AUTOMATIC1111",
        "lm-sys", "ggerganov", "Mozilla-Ocho", "BerriAI",
    ]
    repo_lower = repo.lower()
    if any(b.lower() in repo_lower for b in BLOCKED_REPOS):
        return False

    prompt = (
        "Read this GitHub issue:\n"
        "---\n"
        + text[:400] +
        "\n---\n\n"
        "Answer YES only if ALL of these are true:\n"
        "1. The person wants to USE an AI API in their OWN project (not contribute to one)\n"
        "2. They are a beginner or non-expert looking for a READY solution\n"
        "3. The issue is NOT a bug report, NOT a feature request for another product\n"
        "4. The repo is NOT a major AI framework or company's official repo\n\n"
        "Answer NO if any of these apply:\n"
        "- Bug in someone else's software\n"
        "- Account, billing, or verification problem\n"
        "- Advanced technical discussion\n"
        "- Contributing to an AI library\n\n"
        "Answer ONE word: YES or NO\nAnswer:"
    )
    resp = ask_ai(prompt, temp=0.0)
    return bool(resp and resp.strip().upper().startswith("YES"))

REPLY_STYLES_API = [
    "casual_developer",   # مطور يشارك تجربته بشكل غير رسمي
    "helpful_peer",       # زميل يساعد ويشير للحل
    "been_there",         # شخص مر بنفس المشكلة بالضبط
]

REPLY_STYLES_WIDGET = [
    "satisfied_user",     # صاحب موقع جرّب الويدجيت وأعجبه
    "helpful_fellow",     # شخص يقترح حلاً جاهزاً لمشكلة خدمة العملاء
    "early_adopter",      # شخص اكتشف الحل مبكراً ويريد مشاركته
]

def generate_reply(content: str, platform: str, audience: str | None = None) -> str | None:
    """
    يولد رد طبيعي يناسب نوع الجمهور:
    - api_developer  → يتحدث عن AI API
    - website_owner  → يتحدث عن الويدجيت وخدمة العملاء
    """
    if audience == AUDIENCE_WIDGET:
        style = random.choice(REPLY_STYLES_WIDGET)
        prompt = f"""
You are a website owner who installed the Orgteh AI widget on your site and love it.
You found this post on {platform} from someone who needs automated customer service or a chatbot for their website.
You want to genuinely help by sharing what worked for you.

ABOUT THE WIDGET:
{SITE_CONTEXT}

POST CONTENT:
---
{content[:700]}
---

YOUR STYLE: {style}

STRICT RULES:
1. Detect the language and reply in THE SAME LANGUAGE — if Arabic, reply in Arabic.
2. Write as a REAL website owner, NOT a company. Use "I" not "we".
3. Sound natural and helpful. NOT promotional.
4. Keep it SHORT (3-5 sentences max).
5. Mention orgteh.com/widget naturally — like you discovered it and it solved your problem.
6. Focus on: easy setup (one script), reads website automatically, answers customers 24/7.
7. DO NOT start with "Hi/Hello". DO NOT use bullet points.
8. Output ONLY the reply text.

Examples (adapt to language):
- "Went through the same thing — ended up using the widget from orgteh.com, took me like 5 minutes to install..."
- "I added a chatbot to my store using orgteh.com/widget, it reads all my product pages automatically..."
- "عندي نفس الموضوع في موقعي، جربت ويدجيت orgteh.com وركّبته بسطرين، يقرأ الموقع لحاله..."
- "كنت أبحث عن نفس الشيء، وجدت orgteh.com/widget، يرد على أسئلة العملاء تلقائياً..."
"""
    else:
        # AUDIENCE_API أو غير محدد
        style = random.choice(REPLY_STYLES_API)
        prompt = f"""
You are a developer who uses Orgteh (orgteh.com) for AI API access.
You found this post on {platform} and want to genuinely help.

ABOUT ORGTEH:
{SITE_CONTEXT}

POST CONTENT:
---
{content[:700]}
---

YOUR STYLE: {style}

STRICT RULES:
1. Detect the language and reply in THE SAME LANGUAGE — if Arabic, reply in Arabic.
2. Write as a REAL developer. Use "I" not "we".
3. Sound natural and conversational. NOT salesy.
4. Keep it SHORT (3-5 sentences max).
5. Mention orgteh.com naturally.
6. Only mention features relevant to their specific problem.
7. DO NOT start with "Hi/Hello". DO NOT use bullet points.
8. Output ONLY the reply text.

Examples (adapt to language/situation):
- "Been using orgteh.com API for this, works well — OpenAI-compatible so no code changes..."
- "جربت orgteh.com لنفس الغرض، API متوافق مع OpenAI ويشتغل مباشرة..."
- "عندي تجربة مع هذا، استخدمت orgteh.com وفيه عدة نماذج بـ endpoint موحد..."
"""
    return ask_ai(prompt, temp=0.7)

def generate_email(company: str, snippet: str, audience: str | None = None) -> dict | None:
    """
    يولد إيميل بارد مناسب لنوع الجمهور:
    - api_developer  → يتحدث عن AI API
    - website_owner  → يتحدث عن الويدجيت
    """
    if audience == AUDIENCE_WIDGET:
        prompt = f"""
You are a website owner who uses the Orgteh AI widget and want to recommend it to another business.

COMPANY/BUSINESS NAME: {company}
WHAT THEY DO: {snippet[:500]}

ABOUT THE WIDGET:
{SITE_CONTEXT}

Write a short personal email as a fellow website owner (not a sales rep).
- Detect language from the snippet and reply in THE SAME LANGUAGE. If Arabic content detected, write in Arabic.
- Subject: short and relevant to their business.
- Body: 3-5 sentences. Mention their specific business type. Explain the widget helps answer customer questions automatically by reading their website.
- Sound personal and helpful, not promotional.
- Include orgteh.com/widget naturally.
- Use "I" not "we".

Output STRICT JSON only:
{{"subject": "...", "body": "..."}}
"""
    else:
        prompt = f"""
You are a developer who uses Orgteh API and want to recommend it to another developer/startup.

COMPANY/DEV NAME: {company}
WHAT THEY DO: {snippet[:500]}

ABOUT ORGTEH:
{SITE_CONTEXT}

Write a short personal cold email as a fellow developer.
- Detect language from the snippet and reply in THE SAME LANGUAGE. If Arabic content detected, write in Arabic.
- Subject: short, specific to their use case.
- Body: 4-5 sentences. Reference what they do specifically.
- Sound like sharing a tool that helped you, not selling.
- Include orgteh.com naturally.
- Use "I" not "we".

Output STRICT JSON only:
{{"subject": "...", "body": "..."}}
"""
    resp = ask_ai(prompt, temp=0.6)
    if resp:
        try:
            m = re.search(r'\{.*\}', resp, re.DOTALL)
            if m:
                return json.loads(m.group(0))
        except:
            pass
    return None

# ==========================================
# 6. نظام مانع الحظر (Anti-Ban Engine)
# ==========================================

class AntiBan:
    """
    يتحكم في توقيت الإرسال لكل منصة لتجنب الحظر.
    يستخدم تأخيرات عشوائية وحدوداً يومية صارمة.
    """
    def __init__(self):
        self._day      = datetime.utcnow().date()
        self._counts   = {k: 0 for k in LIMITS}
        self._lock     = threading.Lock()

    def _reset_if_new_day(self):
        today = datetime.utcnow().date()
        if today != self._day:
            self._day    = today
            self._counts = {k: 0 for k in LIMITS}

    def can_act(self, platform: str) -> bool:
        key = f"{platform}_daily"
        with self._lock:
            self._reset_if_new_day()
            return self._counts.get(key, 0) < LIMITS.get(key, 999)

    def record(self, platform: str):
        key = f"{platform}_daily"
        with self._lock:
            self._counts[key] = self._counts.get(key, 0) + 1
            LOCAL_STATS[platform] = LOCAL_STATS.get(platform, 0) + 1
        # حفظ الإحصائيات في Redis كل 5 عمليات
        if sum(LOCAL_STATS.values()) % 5 == 0:
            memory.save_stats(LOCAL_STATS)

    @staticmethod
    def human_delay(base=15, jitter=20):
        """تأخير عشوائي يشبه السلوك البشري."""
        delay = base + random.uniform(0, jitter)
        time.sleep(delay)

    @staticmethod
    def micro_delay():
        time.sleep(random.uniform(2, 6))


antiban = AntiBan()

# ==========================================
# 7. منصات البث - GitHub (مع فلتر المبتدئين)
# ==========================================

def github_loop():
    headers = {"Authorization": f"token {GITHUB_TOKEN}", "Accept": "application/vnd.github.v3+json"}
    while True:
        try:
            if not GITHUB_TOKEN:
                log_activity("GitHub", "معطّل", "—", note="GITHUB_TOKEN مفقود", level="error")
                time.sleep(600)
                continue

            keywords = get_random_keywords(5)
            for kw in keywords:
                if not antiban.can_act("github"):
                    break

                resp = requests.get(
                    f"https://api.github.com/search/issues"
                    f"?q={requests.utils.quote(kw)}+state:open+type:issue"
                    f"&sort=updated&per_page=10",
                    headers=headers, timeout=15
                )
                if resp.status_code != 200:
                    log_activity("GitHub", f"بحث '{kw}'", "api.github.com",
                                 note=f"HTTP {resp.status_code}", level="error")
                    if resp.status_code == 403:
                        time.sleep(300)
                    break

                items = resp.json().get("items", [])
                log_activity("GitHub", f"بحث '{kw}'", "api.github.com",
                             found=len(items),
                             note=f"وجد {len(items)} issue", level="info")

                matched = 0
                skipped_seen = 0
                skipped_ai = 0
                skipped_repo = 0
                for item in items:
                    if not antiban.can_act("github"):
                        break

                    url       = item["html_url"]
                    body_text = (item.get("body") or "")
                    full_text = item["title"] + " " + body_text
                    repo_name = item.get("repository_url", "").split("/")[-2] + "/" + item.get("repository_url", "").split("/")[-1]

                    if memory.seen(url):
                        skipped_seen += 1
                        continue

                    user_id = f"gh:{item.get('user', {}).get('login', '')}"
                    if memory.user_seen(user_id):
                        skipped_seen += 1
                        continue

                    audience = ai_judge(full_text)
                    if not audience:
                        skipped_ai += 1
                        log_activity("GitHub", f"⏭ فُلتر (غير مرتبط)", repo_name,
                                     note=f"{item['title'][:70]}", level="info")
                        continue
                    if not ai_judge_github(full_text, repo=repo_name):
                        skipped_repo += 1
                        log_activity("GitHub", f"⏭ فُلتر (مستودع متقدم)", repo_name,
                                     note=f"{item['title'][:70]}", level="info")
                        continue

                    reply = generate_reply(full_text, "GitHub", audience)
                    if not reply:
                        log_activity("GitHub", "⚠️ AI لم يُنتج ردًّا", repo_name,
                                     note="generate_reply أرجع None", level="warn")
                        continue

                    post = requests.post(
                        item["url"] + "/comments",
                        headers=headers,
                        json={"body": reply},
                        timeout=10
                    )
                    if post.status_code == 201:
                        comment_data = post.json()
                        comment_id = comment_data.get("id")
                        comment_url = comment_data.get("html_url", url)
                        memory.mark(url)
                        memory.mark_user(user_id)
                        memory.log("GitHub", item["title"], url, body_text, reply)
                        antiban.record("github")
                        matched += 1
                        log_activity("GitHub", f"✅ علّق على [{repo_name}]",
                                     item["title"][:60], found=1,
                                     note=f"جمهور: {audience} | 🔗 {comment_url}", level="success")
                        if comment_id:
                            with _our_comments_lock:
                                _our_github_comments.append({
                                    "repo_api": item["url"],
                                    "comment_id": comment_id,
                                    "title": item["title"][:80],
                                    "url": url,
                                    "ts": datetime.now().isoformat(),
                                })
                                if len(_our_github_comments) > 100:
                                    _our_github_comments.pop()
                        antiban.human_delay(15, 15)
                    else:
                        log_activity("GitHub", f"✗ فشل POST", repo_name,
                                     note=f"HTTP {post.status_code} | {item['title'][:50]}", level="error")

                # ملخص نهاية البحث
                log_activity("GitHub", f"ملخص '{kw}'", "api.github.com",
                             found=matched,
                             note=(f"✅ {matched} تعليق | ⏭ {skipped_seen} مكرر "
                                   f"| 🤖 {skipped_ai} غير مرتبط | 🏗 {skipped_repo} متقدم"),
                             level="success" if matched > 0 else "warn")

            time.sleep(random.randint(20, 40))

        except Exception as e:
            log_activity("GitHub", "خطأ", "—", note=str(e)[:80], level="error")
            print(f"GitHub Error: {e}")
            time.sleep(300)

# ==========================================
# ==========================================
# 8. منصات البث - Reddit (OAuth — بدون Playwright/Cookies)
# ==========================================
# المتطلبات في Secrets:
#   REDDIT_CLIENT_ID     — من reddit.com/prefs/apps (Create App → script)
#   REDDIT_CLIENT_SECRET — نفس الصفحة
#   REDDIT_USERNAME      — اسم مستخدم حساب Reddit
#   REDDIT_PASSWORD      — كلمة مرور الحساب
# ─────────────────────────────────────────────────────────────

SEED_SUBREDDITS = [
    # مطورو AI API
    "LocalLLaMA", "MachineLearning", "ChatGPT", "OpenAI",
    "learnmachinelearning", "ArtificialIntelligence", "SideProject",
    "startups", "webdev", "learnprogramming", "Python",
    "programming", "nocode", "AppDev", "reactjs", "fastapi",
    "freelance", "entrepreneur",
    # أصحاب المواقع / خدمة العملاء
    "ecommerce", "shopify", "woocommerce", "smallbusiness",
    "customerservice", "SaaS", "Wordpress",
    # مجتمعات عربية
    "arabs", "saudiarabia", "algeria", "Morocco", "Egypt", "tunisia",
    # أخرى
    "learnpython", "django", "flask",
]

_subs_cache   = list(SEED_SUBREDDITS)
_subs_lock    = threading.Lock()
_subs_refreshed: float = 0.0
SUBS_REFRESH_HRS = 6

# ── Reddit OAuth token ────────────────────────────────────────
_reddit_token:        str   = ""
_reddit_token_expiry: float = 0.0
_reddit_token_lock          = threading.Lock()
_REDDIT_UA = "orgteh-bot/2.0 (by u/{user})"


def _reddit_get_token() -> str:
    """
    يحصل على Access Token بـ Password Grant (script app).
    يجدده تلقائياً قبل انتهائه.
    """
    global _reddit_token, _reddit_token_expiry
    with _reddit_token_lock:
        if _reddit_token and time.time() < _reddit_token_expiry:
            return _reddit_token

        if not all([REDDIT_CLIENT_ID, REDDIT_CLIENT_SECRET,
                    REDDIT_USERNAME, REDDIT_PASSWORD]):
            return ""

        try:
            ua = _REDDIT_UA.format(user=REDDIT_USERNAME)
            r = requests.post(
                "https://www.reddit.com/api/v1/access_token",
                auth=(REDDIT_CLIENT_ID, REDDIT_CLIENT_SECRET),
                data={
                    "grant_type": "password",
                    "username":   REDDIT_USERNAME,
                    "password":   REDDIT_PASSWORD,
                },
                headers={"User-Agent": ua},
                timeout=15,
            )
            if r.status_code == 200:
                data = r.json()
                if "error" in data:
                    log_activity("Reddit", "✗ OAuth فشل", "reddit.com",
                                 note=str(data["error"]), level="error")
                    return ""
                _reddit_token        = data.get("access_token", "")
                expires_in           = data.get("expires_in", 3600)
                _reddit_token_expiry = time.time() + expires_in - 120
                print(f"✅ Reddit OAuth OK (expires in {expires_in//60} دقيقة)")
                log_activity("Reddit", "✅ OAuth نجح", "oauth.reddit.com",
                             note=f"Token صالح لـ {expires_in//60} دقيقة",
                             level="success")
                return _reddit_token
            else:
                log_activity("Reddit", "✗ OAuth HTTP", "reddit.com",
                             note=f"HTTP {r.status_code}: {r.text[:80]}",
                             level="error")
        except Exception as e:
            log_activity("Reddit", "✗ OAuth exception", "reddit.com",
                         note=str(e)[:80], level="error")
    return ""


def _reddit_headers() -> dict | None:
    """يرجع headers جاهزة مع Bearer Token."""
    token = _reddit_get_token()
    if not token:
        return None
    return {
        "Authorization": f"Bearer {token}",
        "User-Agent":    _REDDIT_UA.format(user=REDDIT_USERNAME),
        "Accept":        "application/json",
    }


def _ai_discover_subreddits() -> list:
    """النموذج يقترح سابريدتات."""
    prompt = """We market two products:
1. Orgteh AI API — cheap OpenAI-compatible API for developers
2. Orgteh Widget — AI chatbot widget for website owners (customer service)

List 40 active subreddit names (no r/) for BOTH audiences:
- Developers needing LLM/AI API integration help
- Website/business owners wanting automated customer support
Output JSON array only: ["sub1","sub2",...]"""
    resp = ask_ai(prompt, temp=0.7)
    found = []
    if resp:
        try:
            m = re.search(r"\[.*?\]", resp, re.DOTALL)
            if m:
                for s in json.loads(m.group(0)):
                    s = str(s).strip().lstrip("r/")
                    if s and len(s) <= 30:
                        found.append(s)
        except Exception:
            pass
    return found[:40]


def _refresh_subreddits():
    global _subs_cache, _subs_refreshed
    if time.time() - _subs_refreshed < SUBS_REFRESH_HRS * 3600:
        return
    with _subs_lock:
        new = _ai_discover_subreddits()
        _subs_cache    = list(set(SEED_SUBREDDITS + new))
        _subs_refreshed = time.time()
        print(f"✅ Reddit subreddits: {len(_subs_cache)} إجمالاً")


def _get_subs(n: int = 3) -> list:
    with _subs_lock:
        pool = _subs_cache or SEED_SUBREDDITS
    return random.sample(pool, min(n, len(pool)))


def _reddit_search(sub: str, kw: str, limit: int = 10) -> list:
    """يبحث في سابريدت باستخدام OAuth API."""
    hdrs = _reddit_headers()
    if not hdrs:
        # fallback: القراءة العامة بدون token (للقراءة فقط)
        hdrs = {"User-Agent": "orgteh-reader/1.0"}
        url = f"https://www.reddit.com/r/{sub}/search.json"
    else:
        url = f"https://oauth.reddit.com/r/{sub}/search"

    try:
        r = requests.get(
            url,
            params={"q": kw, "sort": "new", "restrict_sr": 1,
                    "limit": limit, "type": "link"},
            headers=hdrs,
            timeout=12,
        )
        if r.status_code == 401:
            # Token منتهي — نُعيد التوثيق
            global _reddit_token
            _reddit_token = ""
            log_activity("Reddit", "⚠️ Token انتهى", f"r/{sub}",
                         note="يُعيد التوثيق...", level="warn")
            return []
        if r.status_code == 429:
            log_activity("Reddit", "⏳ Rate limit", f"r/{sub}",
                         note="ينتظر 60 ثانية", level="warn")
            time.sleep(60)
            return []
        if r.status_code != 200:
            log_activity("Reddit", f"✗ HTTP {r.status_code}", f"r/{sub}",
                         note=r.text[:80], level="error")
            return []

        children = r.json().get("data", {}).get("children", [])
        posts = [c["data"] for c in children if c.get("kind") == "t3"]
        log_activity("Reddit", f"بحث r/{sub} '{kw}'", f"reddit.com/r/{sub}",
                     found=len(posts),
                     note=f"وجد {len(posts)} منشور", level="info")
        return posts

    except Exception as e:
        log_activity("Reddit", f"✗ خطأ r/{sub}", f"r/{sub}",
                     note=str(e)[:80], level="error")
        return []


def _reddit_comment(post_fullname: str, text: str) -> bool:
    """يضيف تعليقاً باستخدام OAuth API."""
    hdrs = _reddit_headers()
    if not hdrs:
        log_activity("Reddit", "✗ لا token للتعليق", "oauth.reddit.com",
                     note="تحقق من REDDIT_CLIENT_ID/SECRET/USERNAME/PASSWORD",
                     level="error")
        return False
    try:
        r = requests.post(
            "https://oauth.reddit.com/api/comment",
            headers=hdrs,
            data={"api_type": "json", "thing_id": post_fullname, "text": text},
            timeout=15,
        )
        if r.status_code == 200:
            errs = r.json().get("json", {}).get("errors", [])
            if not errs:
                return True
            log_activity("Reddit", "✗ أخطاء API", "oauth.reddit.com",
                         note=str(errs)[:100], level="error")
        elif r.status_code == 403:
            log_activity("Reddit", "✗ 403 محظور", "oauth.reddit.com",
                         note="الحساب محظور من التعليق أو صلاحيات ناقصة",
                         level="error")
        else:
            log_activity("Reddit", f"✗ HTTP {r.status_code}", "oauth.reddit.com",
                         note=r.text[:80], level="error")
    except Exception as e:
        log_activity("Reddit", "✗ exception في التعليق", "oauth.reddit.com",
                     note=str(e)[:80], level="error")
    return False


def reddit_loop():
    """
    يبحث في السابريدتات ويعلق باستخدام Reddit OAuth.
    يعمل بدون Playwright أو Cookies.
    """
    # تحقق من وجود المتغيرات
    if not all([REDDIT_CLIENT_ID, REDDIT_CLIENT_SECRET,
                REDDIT_USERNAME, REDDIT_PASSWORD]):
        missing = [k for k, v in {
            "REDDIT_CLIENT_ID":     REDDIT_CLIENT_ID,
            "REDDIT_CLIENT_SECRET": REDDIT_CLIENT_SECRET,
            "REDDIT_USERNAME":      REDDIT_USERNAME,
            "REDDIT_PASSWORD":      REDDIT_PASSWORD,
        }.items() if not v]
        log_activity("Reddit", "معطّل", "—",
                     note=f"مفاتيح مفقودة: {', '.join(missing)}", level="error")
        print(f"❌ Reddit: مفاتيح مفقودة: {missing}")
        print("   أضفها في HuggingFace Secrets — راجع reddit.com/prefs/apps")
        return

    # اختبار OAuth فوراً
    token = _reddit_get_token()
    if not token:
        print("❌ Reddit: OAuth فشل — تحقق من المفاتيح")
        return

    print(f"✅ Reddit: OAuth جاهز — u/{REDDIT_USERNAME}")
    _refresh_subreddits()

    cycle_r = 0
    while True:
        try:
            _refresh_subreddits()

            if not antiban.can_act("reddit"):
                log_activity("Reddit", "⏸ الحد اليومي", "—",
                             note=f"{LOCAL_STATS.get('reddit',0)}/{LIMITS['reddit_daily']}",
                             level="warn")
                time.sleep(600)
                continue

            cycle_r += 1
            subs = _get_subs(3)
            kws  = get_random_keywords(3)
            print(f"\n🤖 Reddit دورة #{cycle_r} | {subs} | {kws}")

            for sub, kw in zip(subs, kws):
                if not antiban.can_act("reddit"):
                    break

                posts = _reddit_search(sub, kw, limit=8)
                if not posts:
                    continue

                matched_r    = 0
                skipped_seen = 0
                skipped_ai   = 0

                for post in posts:
                    if not antiban.can_act("reddit"):
                        break

                    post_url  = f"https://reddit.com{post.get('permalink','')}"
                    post_id   = post.get("name", "")
                    author    = post.get("author", "")
                    user_id   = f"rd:{author}"
                    full_text = post.get("title","") + " " + (post.get("selftext") or "")

                    if not post_id or not author or author in ("[deleted]", "AutoModerator"):
                        continue
                    if memory.seen(post_url) or memory.user_seen(user_id):
                        skipped_seen += 1
                        continue

                    audience = ai_judge(full_text)
                    if not audience:
                        skipped_ai += 1
                        log_activity("Reddit", f"⏭ فُلتر r/{sub}",
                                     post.get("title","")[:70],
                                     note="غير مرتبط بمنتجاتنا", level="info")
                        continue

                    reply = generate_reply(full_text, "Reddit", audience)
                    if not reply:
                        log_activity("Reddit", "⚠️ AI لم يُنتج ردًّا",
                                     post.get("title","")[:60],
                                     note="generate_reply أرجع None", level="warn")
                        continue

                    ok = _reddit_comment(post_id, reply)
                    if ok:
                        memory.mark(post_url)
                        memory.mark_user(user_id)
                        memory.log("Reddit", post.get("title",""), post_url,
                                   full_text[:300], reply)
                        antiban.record("reddit")
                        matched_r += 1
                        log_activity("Reddit", f"✅ تعليق r/{sub}",
                                     post.get("title","")[:70],
                                     found=1,
                                     note=f"جمهور: {audience} | 🔗 {post_url}",
                                     level="success")
                        with _our_comments_lock:
                            _our_reddit_comments.append({
                                "post_url": post_url,
                                "post_id":  post_id,
                                "sub":      sub,
                                "title":    post.get("title","")[:80],
                                "ts":       datetime.now().isoformat(),
                            })
                            if len(_our_reddit_comments) > 100:
                                _our_reddit_comments.pop()
                        antiban.human_delay(90, 90)
                        break
                    else:
                        log_activity("Reddit", f"✗ فشل التعليق r/{sub}",
                                     post.get("title","")[:70],
                                     note="راجع سجل الأخطاء أعلاه", level="error")

                log_activity("Reddit", f"ملخص r/{sub} '{kw}'",
                             f"reddit.com/r/{sub}", found=matched_r,
                             note=(f"✅ {matched_r} تعليق | ⏭ {skipped_seen} مكرر "
                                   f"| 🤖 {skipped_ai} غير مرتبط"),
                             level="success" if matched_r > 0 else "warn")

        except Exception as e:
            log_activity("Reddit", "خطأ في الحلقة", "—",
                         note=str(e)[:80], level="error")
            print(f"Reddit loop error: {e}")
        time.sleep(random.randint(400, 700))

# ==========================================

SO_API_KEY = os.getenv("STACKOVERFLOW_API_KEY", "")   # اختياري — يرفع الحد من 300 لـ 10000/يوم

def stackoverflow_loop():
    """
    Stack Overflow API — يجيب على الأسئلة المتعلقة بـ AI API.
    يستخدم /answers endpoint لإضافة إجابات على الأسئلة المفتوحة.
    """
    base_search = "https://api.stackexchange.com/2.3/search/advanced"
    base_answer = "https://api.stackexchange.com/2.3/questions/{}/answers"
    base_post   = "https://api.stackexchange.com/2.3/answers/add"  # يتطلب OAuth

    while True:
        try:
            if not antiban.can_act("stackoverflow"):
                time.sleep(600)
                continue

            kw = random.choice(get_random_keywords(1))
            print(f"🔍 StackOverflow: يبحث بـ '{kw}'")
            params = {
                "q": kw, "site": "stackoverflow",
                "sort": "creation", "order": "desc",
                "pagesize": 10, "filter": "withbody",
                "tagged": "python;artificial-intelligence;openai-api",
                "nottagged": "answered",
            }
            if SO_API_KEY:
                params["key"] = SO_API_KEY

            resp = requests.get(base_search, params=params, timeout=15)
            if resp.status_code != 200:
                log_activity("StackOverflow", f"بحث '{kw}'", "stackoverflow.com",
                             note=f"HTTP {resp.status_code}", level="error")
                time.sleep(300)
                continue

            items = resp.json().get("items", [])
            if items:
                log_activity("StackOverflow", f"بحث '{kw}'", "stackoverflow.com",
                             found=len(items), note=f"وجد {len(items)} سؤال", level="info")
            else:
                log_activity("StackOverflow", f"بحث '{kw}'", "stackoverflow.com",
                             found=0, note="لا أسئلة مفتوحة", level="warn")
            for q in items:
                if not antiban.can_act("stackoverflow"):
                    break

                q_id    = q.get("question_id")
                url     = q.get("link", "")
                owner   = q.get("owner", {})
                user_id = f"so:{owner.get('user_id','')}"
                title   = q.get("title", "")
                body    = re.sub(r"<[^>]+>", " ", q.get("body", ""))
                full_text = title + " " + body

                if memory.seen(url) or memory.user_seen(user_id):
                    print(f"  ⏭ SO skip (seen): {title[:45]}")
                    continue
                audience = ai_judge(full_text)
                if not audience:
                    print(f"  ⏭ SO skip (not relevant): {title[:45]}")
                    continue
                print(f"  ✅ SO match [{audience}]: {title[:45]}")
                reply = generate_reply(full_text, "Stack Overflow", audience)
                if not reply:
                    continue
                memory.mark(url)
                memory.mark_user(user_id)
                memory.log("StackOverflow", title, url, body[:300], reply)
                antiban.record("stackoverflow")
                log_activity("StackOverflow", "إجابة", title[:70],
                             found=1, note=f"جمهور: {audience}", level="success")
                print(f"  ✅✅ SO logged: {title[:45]}")
                antiban.micro_delay()

        except Exception as e:
            print(f"SO Error: {e}")
        time.sleep(random.randint(120, 240))


# ==========================================
# 9b. منصات البث - ProductHunt (تعليقات على المنتجات الجديدة)
# ==========================================

# ProductHunt — API Key + Secret مباشرة (يحصل على Token تلقائياً)
PH_API_KEY    = os.getenv("PRODUCTHUNT_API_KEY",    "")
PH_API_SECRET = os.getenv("PRODUCTHUNT_API_SECRET", "")

_ph_token:         str   = ""
_ph_token_expiry:  float = 0.0
_ph_token_lock     = threading.Lock()


def _ph_get_token() -> str:
    """
    يحصل على Access Token تلقائياً من API Key + Secret.
    يجدده عند انتهائه — لا خطوات يدوية.
    """
    global _ph_token, _ph_token_expiry
    with _ph_token_lock:
        if _ph_token and time.time() < _ph_token_expiry:
            return _ph_token
        if not PH_API_KEY or not PH_API_SECRET:
            return ""
        try:
            r = requests.post(
                "https://api.producthunt.com/v2/oauth/token",
                json={
                    "client_id":     PH_API_KEY,
                    "client_secret": PH_API_SECRET,
                    "grant_type":    "client_credentials",
                },
                timeout=15,
            )
            if r.status_code == 200:
                data = r.json()
                _ph_token        = data.get("access_token", "")
                expires_in       = data.get("expires_in", 7200)
                _ph_token_expiry = time.time() + expires_in - 120
                print(f"✅ ProductHunt token OK (expires in {expires_in//3600}h)")
                return _ph_token
            else:
                print(f"ProductHunt token error: {r.status_code} {r.text[:100]}")
        except Exception as e:
            print(f"ProductHunt token error: {e}")
        return ""


def producthunt_loop():
    """يعلق على المنتجات الجديدة في ProductHunt."""
    gql_url = "https://api.producthunt.com/v2/api/graphql"

    query = """
    {
      posts(first: 20, order: NEWEST, topic: "artificial-intelligence") {
        edges {
          node {
            id name tagline description url votesCount
            user { username }
          }
        }
      }
    }
    """

    while True:
        try:
            if not antiban.can_act("producthunt"):
                time.sleep(1800)
                continue

            token = _ph_get_token()
            if not token:
                log_activity("ProductHunt", "معطّل", "—",
                             note="تحقق من PRODUCTHUNT_API_KEY/SECRET", level="error")
                time.sleep(3600)
                continue
            # ملاحظة: ProductHunt API بـ client_credentials لا يدعم نشر التعليقات
            # يحتاج user-level OAuth — سنستخدم PH للقراءة والتسجيل فقط حالياً

            headers = {
                "Authorization": f"Bearer {token}",
                "Content-Type":  "application/json",
            }

            resp = requests.post(gql_url, json={"query": query}, headers=headers, timeout=15)
            if resp.status_code != 200:
                log_activity("ProductHunt", "جلب منتجات", "producthunt.com",
                             note=f"HTTP {resp.status_code}", level="error")
                time.sleep(600)
                continue

            posts = resp.json().get("data", {}).get("posts", {}).get("edges", [])
            log_activity("ProductHunt", "جلب منتجات AI", "producthunt.com",
                         found=len(posts), note=f"{len(posts)} منتج جديد", level="info")

            matched_ph = 0
            skipped_seen_ph = 0
            skipped_ai_ph = 0
            for edge in posts:
                if not antiban.can_act("producthunt"):
                    break

                node      = edge["node"]
                url       = node.get("url", "")
                post_id   = node.get("id", "")
                name      = node.get("name","")
                user_id   = f"ph:{node.get('user',{}).get('username','')}"
                full_text = (name + " " + node.get("tagline","") + " " +
                             (node.get("description") or ""))

                if memory.seen(url) or memory.user_seen(user_id):
                    skipped_seen_ph += 1
                    continue

                audience = ai_judge(full_text)
                if not audience:
                    skipped_ai_ph += 1
                    log_activity("ProductHunt", f"⏭ فُلتر",
                                 name[:70], note="غير مرتبط بمنتجاتنا", level="info")
                    continue

                print(f"  ✅ PH match [{audience}]: {name[:40]}")
                reply = generate_reply(full_text, "ProductHunt", audience)
                if not reply:
                    continue

                safe_reply = reply.replace('"', "'").replace("\n", " ")
                mutation = (
                    'mutation { createComment(input: {' +
                    f'postId: "{post_id}" body: "{safe_reply}"' +
                    '}) { comment { id } errors { field message } } }'
                )
                post_resp = requests.post(
                    gql_url, json={"query": mutation},
                    headers=headers, timeout=10
                )
                if post_resp.status_code == 200:
                    resp_data = post_resp.json()
                    errs = resp_data.get("errors", [])
                    inner_errs = (resp_data.get("data",{})
                                  .get("createComment",{})
                                  .get("errors",[]))
                    all_errs = errs + inner_errs
                    if not all_errs:
                        memory.mark(url)
                        memory.mark_user(user_id)
                        memory.log("ProductHunt", name, url, full_text[:300], reply)
                        antiban.record("producthunt")
                        matched_ph += 1
                        log_activity("ProductHunt", f"✅ تعليق على منتج",
                                     name[:60], found=1,
                                     note=f"جمهور: {audience} | 🔗 {url}", level="success")
                        print(f"✅ ProductHunt: {name[:50]}")
                        antiban.human_delay(60, 60)
                    else:
                        log_activity("ProductHunt", f"✗ أخطاء GraphQL",
                                     name[:60],
                                     note=str(all_errs)[:120], level="error")
                else:
                    log_activity("ProductHunt", f"✗ فشل POST",
                                 name[:60],
                                 note=f"HTTP {post_resp.status_code}", level="error")

            log_activity("ProductHunt", "ملخص الدورة", "producthunt.com",
                         found=matched_ph,
                         note=(f"✅ {matched_ph} تعليق | ⏭ {skipped_seen_ph} مكرر "
                               f"| 🤖 {skipped_ai_ph} غير مرتبط"),
                         level="success" if matched_ph > 0 else "warn")

        except Exception as e:
            log_activity("ProductHunt", "خطأ", "—", note=str(e)[:80], level="error")
            print(f"ProductHunt Error: {e}")
        time.sleep(random.randint(600, 900))

# ==========================================
# 10. منصات البث - Dev.to
# ==========================================

def devto_loop():
    """Dev.to API - التعليق على مقالات المطورين."""
    headers = {"api-key": DEVTO_API_KEY or "", "Content-Type": "application/json"}
    while True:
        try:
            if not DEVTO_API_KEY:
                log_activity("Dev.to", "معطّل", "—", note="DEVTO_API_KEY مفقود", level="error")
                time.sleep(1800)
                continue
            if not antiban.can_act("devto"):
                time.sleep(1800)
                continue

            for tag in ["api", "llm", "openai", "chatbot", "artificialintelligence"]:
                resp = requests.get(
                    f"https://dev.to/api/articles?tag={tag}&top=1&per_page=5",
                    timeout=10
                )
                if resp.status_code != 200:
                    log_activity("Dev.to", f"بحث #{tag}", "dev.to",
                                 note=f"HTTP {resp.status_code}", level="error")
                    continue

                articles = resp.json()
                log_activity("Dev.to", f"بحث #{tag}", "dev.to",
                             found=len(articles),
                             note=f"وجد {len(articles)} مقالة", level="info")

                matched_dt = 0
                skipped_seen_dt = 0
                skipped_ai_dt = 0
                for article in articles:
                    title_a   = article.get("title","")
                    full_text = title_a + " " + (article.get("description") or "")
                    url       = article.get("url","")
                    user_id   = f"devto:{article.get('user',{}).get('username','')}"

                    if not url or memory.seen(url) or memory.user_seen(user_id):
                        skipped_seen_dt += 1
                        continue

                    audience = ai_judge(full_text)
                    if not audience:
                        skipped_ai_dt += 1
                        log_activity("Dev.to", f"⏭ فُلتر #{tag}",
                                     title_a[:70], note="غير مرتبط بمنتجاتنا", level="info")
                        continue

                    print(f"  ✅ Dev.to match [{audience}]: {title_a[:45]}")
                    reply = generate_reply(full_text, "Dev.to", audience)
                    if not reply:
                        log_activity("Dev.to", "⚠️ AI لم يُنتج ردًّا", title_a[:60],
                                     note="generate_reply أرجع None — NVIDIA API مشغول؟",
                                     level="warn")
                        continue

                    post = requests.post(
                        "https://dev.to/api/comments",
                        headers=headers,
                        json={"body_markdown": reply, "article_id": article["id"]},
                        timeout=10
                    )
                    if post.status_code in (200, 201):
                        memory.mark(url)
                        memory.mark_user(user_id)
                        memory.log("Dev.to", title_a, url, full_text, reply)
                        antiban.record("devto")
                        matched_dt += 1
                        log_activity("Dev.to", f"✅ تعليق #{tag}",
                                     title_a[:60], found=1,
                                     note=f"جمهور: {audience} | 🔗 {url}", level="success")
                        print(f"✅ Dev.to: {title_a[:50]}")
                        antiban.human_delay(90, 90)
                        break
                    else:
                        log_activity("Dev.to", f"✗ فشل POST #{tag}",
                                     title_a[:60],
                                     note=f"HTTP {post.status_code} | {post.text[:100]}",
                                     level="error")

                log_activity("Dev.to", f"ملخص #{tag}", "dev.to",
                             found=matched_dt,
                             note=(f"✅ {matched_dt} تعليق | ⏭ {skipped_seen_dt} مكرر "
                                   f"| 🤖 {skipped_ai_dt} غير مرتبط"),
                             level="success" if matched_dt > 0 else "warn")

        except Exception as e:
            log_activity("Dev.to", "خطأ", "—", note=str(e)[:80], level="error")
            print(f"Dev.to Error: {e}")
        time.sleep(random.randint(1800, 2700))

# ==========================================
# 11. Discord — معطّل (HuggingFace يحجب discord.com)
# ==========================================
# HuggingFace Spaces تحجب discord.com على مستوى DNS.
# لتفعيل Discord: شغّل discord_worker.py على Railway (ملف منفصل).
# في الوقت الحالي هذا الخيط لا يعمل ويُسجّل سبب التعطيل فقط.

DC_SEED_GUILDS = [
    "1050422060328587374",  # Hugging Face
    "879548962464493619",   # LangChain
    "1038516858214187058",  # OpenAI Community
    "974519864045756446",   # AI/ML
    "822462215499587604",   # Python Discord
    "267624335836053506",   # Programming
    "889872606868959273",   # Indie Hackers
    "1009953904836329512",  # مطورون عرب
]


def discord_monitor_loop():
    """
    معطّل — HuggingFace يحجب discord.com على مستوى DNS.
    يُسجّل رسالة واضحة ويخرج دون إهدار موارد.
    """
    log_activity("Discord", "❌ محجوب على HuggingFace", "discord.com",
                 note="HuggingFace يحجب discord.com — لا حل في ملف واحد",
                 level="error")
    print("❌ Discord: محجوب على HuggingFace Spaces — الخيط متوقف")
    # لا while loop — لا موارد مهدرة


# ==========================================

# ── تدفئة تدريجية (Warm-up): في أول أيام التشغيل نرسل أقل ──
# اليوم 1: 200 | اليوم 3: 500 | اليوم 7: 1500 | اليوم 14+: 5000
_BOOT_TIME = datetime.utcnow()

def _email_daily_cap() -> int:
    """يزيد الحد تدريجياً بدلاً من القفز لـ 5000 فجأة."""
    days = (datetime.utcnow() - _BOOT_TIME).days
    if days < 1:   return 200
    if days < 3:   return 500
    if days < 7:   return 1500
    if days < 14:  return 3000
    return 5000

# ── قائمة انتظار الإرسال (لتوزيع الإيميلات على اليوم كله) ──
_email_queue: list[dict] = []
_email_queue_lock = threading.Lock()

# ── أوقات الإرسال البشرية (نتجنب منتصف الليل وأوقات الذروة المشبوهة) ──
# نرسل على مدار الساعة — HuggingFace يعمل 24/7
# (القيد الزمني كان يمنع الإرسال ساعات 23-7 UTC أي ساعات النهار في الشرق الأوسط)
SEND_HOURS = list(range(0, 24))   # 24/7

def _in_send_window() -> bool:
    return True  # إرسال على مدار الساعة

def _build_email_message(from_name: str, to: str, subject: str, body: str) -> MIMEMultipart:
    """يبني رسالة إيميل احترافية تتجنب مرشحات Spam."""
    msg = MIMEMultipart("alternative")
    # From بصيغة اسم + إيميل لزيادة الثقة
    msg["From"]       = formataddr((from_name, SMTP_EMAIL))
    msg["To"]         = to
    msg["Subject"]    = subject
    msg["Message-ID"] = make_msgid(domain=SMTP_EMAIL.split("@")[-1])
    msg["Date"]       = datetime.utcnow().strftime("%a, %d %b %Y %H:%M:%S +0000")
    # نص عادي فقط (plain text أقل احتمالاً للـ Spam من HTML)
    msg.attach(MIMEText(body, "plain", "utf-8"))
    return msg

def send_email(to: str, subject: str, body: str, sender_name: str = "Ahmed") -> tuple[bool, str]:
    """
    يرسل إيميل مع:
    - اسم مرسل بشري
    - Message-ID فريد
    - تأخير عشوائي قبل الإرسال
    - إعادة المحاولة مرة واحدة عند الفشل
    """
    if not SMTP_EMAIL or not SMTP_PASSWORD:
        return False, "SMTP غير مهيأ"
    if not _in_send_window():
        return False, "خارج نافذة الإرسال"

    msg = _build_email_message(sender_name, to, subject, body)

    for attempt in range(2):
        try:
            srv = smtplib.SMTP(SMTP_SERVER, SMTP_PORT, timeout=30)
            srv.ehlo()
            srv.starttls()
            srv.ehlo()
            srv.login(SMTP_EMAIL, SMTP_PASSWORD)
            srv.sendmail(SMTP_EMAIL, [to], msg.as_string())
            srv.quit()
            return True, "تم الإرسال"
        except smtplib.SMTPRecipientsRefused:
            return False, "إيميل مرفوض"
        except smtplib.SMTPDataError as e:
            return False, f"خطأ بيانات: {e}"
        except Exception as e:
            if attempt == 0:
                time.sleep(random.uniform(5, 15))
            else:
                return False, str(e)
    return False, "فشل بعد المحاولات"


def test_smtp_connection() -> tuple[bool, str]:
    """يختبر اتصال SMTP ويُعيد (نجاح, رسالة)."""
    if not SMTP_EMAIL or not SMTP_PASSWORD:
        return False, "SMTP_EMAIL أو SMTP_PASSWORD مفقود"
    try:
        srv = smtplib.SMTP(SMTP_SERVER, SMTP_PORT, timeout=15)
        srv.ehlo()
        srv.starttls()
        srv.ehlo()
        srv.login(SMTP_EMAIL, SMTP_PASSWORD)
        srv.quit()
        return True, f"✅ SMTP متصل: {SMTP_SERVER}:{SMTP_PORT} ({SMTP_EMAIL})"
    except smtplib.SMTPAuthenticationError:
        return False, f"❌ خطأ في كلمة المرور — تحقق من SMTP_PASSWORD"
    except smtplib.SMTPConnectError as e:
        return False, f"❌ لا يمكن الاتصال بـ {SMTP_SERVER}:{SMTP_PORT} — {e}"
    except Exception as e:
        return False, f"❌ {type(e).__name__}: {str(e)[:80]}"


# ── مولّد أسماء المرسل العشوائية لتبدو بشرية ──
SENDER_NAMES = [
    "Ahmed", "Omar", "Sara", "Youssef", "Layla",
    "Alex", "Chris", "Maria", "James", "Anna",
]

def _random_sender() -> str:
    return random.choice(SENDER_NAMES)

# استراتيجيات البحث عن الإيميلات والشركات الناشئة
EMAIL_SEARCH_QUERIES = [

    # ════ جمهور 1: مطورو AI API ════
    "site:github.io ai api project contact email",
    "site:github.com llm api integration project contact",
    '"llm api" developer project contact email',
    '"ai api" developer "contact" OR "email" site:github.com',
    '"how to use llm api" developer email',
    '"integrate ai model" project developer contact',
    "site:producthunt.com ai chatbot api developer 2024",
    "startup ai api integration developer email contact",
    "site:indie.hackers.com ai api llm project",
    '"building with llm" developer email contact',
    '"llm api" OR "ai api" developer startup email contact',
    '"chat completions" developer project contact email',

    # ════ جمهور 2: أصحاب المواقع — ويدجيت / خدمة عملاء ════

    # EN
    '"customer service chatbot" small business contact',
    '"add chatbot to website" owner contact email',
    '"automated customer support" website owner email',
    "ecommerce store chatbot customer service contact",
    '"website chatbot" business owner contact',
    "shopify store owner customer support automation email",
    "woocommerce site owner chatbot email contact",
    "saas product owner customer support chatbot",

    # AR — أصحاب المواقع العرب (أولوية)
    "موقع عربي خدمة عملاء شات بوت",
    "متجر الكتروني عربي دعم عملاء تلقائي",
    "صاحب موقع عربي ويدجيت",
    "شات بوت للمتجر الإلكتروني العربي",
    "site:salla.sa chatbot خدمة عملاء",
    "site:zid.sa روبوت محادثة",
    "متاجر سلة ويدجيت خدمة عملاء",

    # متاجر ومواقع ناشئة
    "site:indie.hackers.com customer support chatbot website",
    "site:producthunt.com customer service ai widget",
    '"customer support" "website" owner email contact startup',
]

# ── نظام إيميل موثوق: فصل البحث عن الإرسال ──
# البحث يملأ _email_queue، والإرسال يُفرّغه بإيقاع بشري

# Headers تشبه المتصفح لتجنب الحظر
_EMAIL_HEADERS = {
    "User-Agent": (
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
        "AppleWebKit/537.36 (KHTML, like Gecko) "
        "Chrome/122.0.0.0 Safari/537.36"
    ),
    "Accept":          "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.9,ar;q=0.8",
    "Accept-Encoding": "gzip, deflate, br",
    "DNT":             "1",
    "Connection":      "keep-alive",
}

_SKIP_DOMAINS = [
    "facebook.com","linkedin.com","twitter.com","x.com","youtube.com",
    "instagram.com","tiktok.com","reddit.com","google.com","amazon.com",
    "wikipedia.org","github.com","stackoverflow.com",
]

def _web_search(query: str, max_results: int = 8) -> list:
    """
    يبحث في محركات بحث متعددة بالترتيب حتى يحصل على نتائج.
    المحركات: Bing (الأموثق على HuggingFace) → DDG → Common Crawl Index.
    """
    results = _bing_search(query, max_results)
    if results:
        return results
    results = _ddg_search(query, max_results)
    if results:
        return results
    # آخر خيار: ابحث مباشرة في GitHub وdev.to وindie hackers
    results = _direct_source_search(query, max_results)
    return results


def _bing_search(query: str, max_results: int = 8) -> list:
    """
    Bing HTML search — يعمل بشكل موثوق على HuggingFace.
    لا يحتاج API key.
    """
    try:
        r = requests.get(
            "https://www.bing.com/search",
            params={"q": query, "count": max_results + 5, "setlang": "en"},
            headers={**_EMAIL_HEADERS,
                     "Accept-Language": "en-US,en;q=0.9",
                     "Referer": "https://www.bing.com/"},
            timeout=15,
            allow_redirects=True,
        )
        if r.status_code != 200:
            log_activity("Email/Bing", f"بحث '{query[:45]}'", "bing.com",
                         note=f"HTTP {r.status_code}", level="error")
            return []

        # استخراج الروابط من Bing HTML
        links = re.findall(
            r'<h2[^>]*><a[^>]+href="(https?://[^"]+)"[^>]*>([^<]+)<',
            r.text,
        )
        if not links:
            # pattern بديل
            links = re.findall(
                r'<a[^>]+href="(https?://[^"]+)"[^>]*class="[^"]*title[^"]*"[^>]*>([^<]{5,100})<',
                r.text,
            )
        if not links:
            # pattern عام
            links = re.findall(
                r'href="(https?://(?!www\.bing\.com)[^"]{10,200})"[^>]*>([^<]{5,100})<\/a>',
                r.text,
            )

        results = []
        seen_domains = set()
        skip = _SKIP_DOMAINS + ["bing.com", "microsoft.com", "msn.com"]
        for href, title in links:
            href = href.strip()
            if not href.startswith("http"):
                continue
            if any(d in href for d in skip):
                continue
            domain = href.split("/")[2] if "/" in href else href
            if domain in seen_domains:
                continue
            seen_domains.add(domain)
            results.append((href, title.strip()))
            if len(results) >= max_results:
                break

        log_activity("Email/Bing", f"بحث '{query[:45]}'", "bing.com",
                     found=len(results),
                     note=f"وجد {len(results)} رابط",
                     level="info" if results else "warn")
        return results
    except Exception as e:
        log_activity("Email/Bing", f"بحث '{query[:45]}'", "bing.com",
                     note=str(e)[:80], level="error")
        return []


def _ddg_search(query: str, max_results: int = 8) -> list:
    """DuckDuckGo fallback."""
    try:
        r = requests.post(
            "https://html.duckduckgo.com/html/",
            data={"q": query, "b": "", "kl": ""},
            headers={**_EMAIL_HEADERS,
                     "Content-Type": "application/x-www-form-urlencoded"},
            timeout=15,
            allow_redirects=True,
        )
        if r.status_code not in (200, 202):
            return []
        links = re.findall(
            r'<a[^>]+class="result__a"[^>]*href="([^"]+)"[^>]*>([^<]+)<',
            r.text,
        )
        if not links:
            links = re.findall(
                r'href="(https?://[^"]{10,200})"[^>]*>([^<]{5,100})<',
                r.text,
            )
        results = []
        for href, title in links:
            if "uddg=" in href:
                m = re.search(r"uddg=([^&]+)", href)
                href = requests.utils.unquote(m.group(1)) if m else href
            href = href.strip()
            if not href.startswith("http"):
                continue
            if any(d in href for d in _SKIP_DOMAINS + ["duckduckgo.com"]):
                continue
            results.append((href, title.strip()))
            if len(results) >= max_results:
                break
        if results:
            log_activity("Email/DDG", f"بحث '{query[:45]}'", "duckduckgo.com",
                         found=len(results), note=f"وجد {len(results)} رابط", level="info")
        return results
    except Exception:
        return []


def _direct_source_search(query: str, max_results: int = 8) -> list:
    """
    بحث مباشر في مصادر موثوقة: GitHub API، Indie Hackers، dev.to.
    يُستخدم عندما تفشل محركات البحث.
    """
    results = []
    clean = re.sub(r"[^a-zA-Z0-9 ]", " ", query).strip()[:80]

    # ── GitHub: ابحث عن repos وusers بإيميلاتهم ──
    if GITHUB_TOKEN:
        try:
            kw = clean.split()[0] if clean else "ai api"
            r = requests.get(
                f"https://api.github.com/search/repositories"
                f"?q={requests.utils.quote(kw)}+topic:ai-api"
                f"&sort=updated&per_page=10",
                headers={"Authorization": f"token {GITHUB_TOKEN}",
                         "Accept": "application/vnd.github.v3+json"},
                timeout=12,
            )
            if r.status_code == 200:
                for repo in r.json().get("items", [])[:10]:
                    owner_url = repo.get("owner", {}).get("html_url", "")
                    desc      = repo.get("description") or ""
                    name      = repo.get("full_name","")
                    if owner_url and name:
                        results.append((f"https://github.com/{name}", desc or name))
                if results:
                    log_activity("Email/GitHub", f"بحث '{clean[:40]}'", "api.github.com",
                                 found=len(results), note=f"وجد {len(results)} repo", level="info")
        except Exception:
            pass

    # ── Indie Hackers RSS ──
    if len(results) < max_results:
        try:
            r = requests.get(
                "https://www.indiehackers.com/posts.json?limit=20",
                headers=_EMAIL_HEADERS, timeout=10,
            )
            if r.status_code == 200:
                for post in r.json().get("posts", [])[:10]:
                    url   = "https://www.indiehackers.com" + post.get("url","")
                    title = post.get("title","")
                    if url and title and any(
                        kw.lower() in (title + post.get("content","")).lower()
                        for kw in ["api","chatbot","ai","llm","bot"]
                    ):
                        results.append((url, title))
        except Exception:
            pass

    return results[:max_results]

# ── scrapling للزحف الذكي (إن كانت مثبتة) ──
try:
    from scrapling import Fetcher as _ScrapFetcher
    _SCRAPLING_OK = True
except ImportError:
    _SCRAPLING_OK = False

def _fetch_page(url: str) -> tuple:
    """
    يجلب الصفحة بـ scrapling إن كانت متاحة، وإلا بـ requests.
    يرجع (html_text, plain_text).
    """
    if _SCRAPLING_OK:
        try:
            fetcher = _ScrapFetcher(auto_match=False)
            page = fetcher.get(url, timeout=12)
            raw  = page.html_content
            text = page.get_all_text(ignore_tags=("script","style","head"))
            return raw, text
        except Exception:
            pass
    # fallback: requests عادي
    r = requests.Session()
    r.headers.update(_EMAIL_HEADERS)
    resp = r.get(url, timeout=12, allow_redirects=True)
    resp.raise_for_status()
    raw  = resp.text
    text = re.sub(r"<[^>]+>", " ", raw)
    text = re.sub(r"\s+", " ", text).strip()
    return raw, text


EMAIL_PATTERN = re.compile(
    r"[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}"
)
BAD_EMAIL_EXT  = (".png",".jpg",".js",".css",".svg",".gif",".woff",".ico")
BAD_EMAIL_WORD = ("example","noreply","no-reply","support@","info@",
                  "contact@","hello@","admin@","test@","email@","webmaster",
                  "postmaster","bounce","mailer-daemon")


def _extract_emails(raw: str) -> list:
    found = list(set(EMAIL_PATTERN.findall(raw)))
    return [
        e for e in found
        if not any(e.endswith(x) for x in BAD_EMAIL_EXT)
        and not any(w in e.lower() for w in BAD_EMAIL_WORD)
        and len(e) < 60
        and "." in e.split("@")[-1]
    ]


def email_harvester():
    """
    يبحث عن إيميلات مطورين وأصحاب مواقع:
    DDG → فتح المواقع بـ scrapling/requests → استخراج إيميلات.
    """
    query = random.choice(EMAIL_SEARCH_QUERIES)
    method = "Bing+DDG+GitHub"
    targets = _web_search(query, max_results=10)
    log_activity("Email", f"بحث جديد", query[:60],
                 found=len(targets),
                 note=f"محركات بحث: {method} | وجد {len(targets)} هدف",
                 level="info" if targets else "warn")
    print(f"\n📥 Email harvest [{method}]: '{query[:50]}' → {len(targets)} هدف")

    total_found = 0
    total_queued = 0

    for url, title in targets:
        if memory.seen(url):
            continue
        try:
            raw, page_text = _fetch_page(url)

            # استخراج إيميل من GitHub profile API إذا كان الرابط على GitHub
            if "github.com/" in url and raw:
                parts = url.rstrip("/").split("/")
                if len(parts) >= 5 and parts[3]:  # github.com/owner/repo
                    owner = parts[3]
                    try:
                        gh_headers = {"Authorization": f"token {GITHUB_TOKEN}",
                                      "Accept": "application/vnd.github.v3+json"}
                        u = requests.get(f"https://api.github.com/users/{owner}",
                                         headers=gh_headers, timeout=8)
                        if u.status_code == 200:
                            gh_email = u.json().get("email") or ""
                            if gh_email and "@" in gh_email:
                                raw += f" {gh_email} "
                    except Exception:
                        pass

            found = _extract_emails(raw)

            if not found:
                log_activity("Email", f"فتح الموقع", url[:70],
                             found=0, note="لا يوجد إيميل في الصفحة", level="info")
                continue

            total_found += len(found)
            log_activity("Email", f"إيميلات وُجدت", url[:70],
                         found=len(found),
                         note=f"وجد {len(found)} إيميل: {', '.join(found[:3])}", level="success")
            LOCAL_STATS["emails_found"] = LOCAL_STATS.get("emails_found", 0) + len(found)

            audience = ai_judge(page_text[:1500])
            if not audience:
                log_activity("Email", "فلتر الجمهور", url[:70],
                             note="الموقع غير مرتبط بمنتجاتنا", level="warn")
                continue

            company = title or (url.split("/")[2] if "/" in url else url)
            data = generate_email(company, page_text[:600], audience)
            if not data:
                continue

            added = 0
            with _email_queue_lock:
                for em in found[:2]:
                    email_id = f"email:{em}"
                    if not memory.user_seen(email_id):
                        _email_queue.append({
                            "to":       em,
                            "subject":  data["subject"],
                            "body":     data["body"],
                            "url":      url,
                            "title":    title,
                            "email_id": email_id,
                        })
                        added += 1
            memory.mark(url)
            if added:
                total_queued += added
                LOCAL_STATS["emails_queued"] = LOCAL_STATS.get("emails_queued", 0) + added
                log_activity("Email", "أُضيف للقائمة", url[:70],
                             found=added,
                             note=f"جمهور: {audience} | {added} إيميل جاهز للإرسال",
                             level="success")
            time.sleep(random.uniform(1, 3))

        except Exception as e:
            log_activity("Email", "خطأ في الزحف", url[:70],
                         note=str(e)[:80], level="error")
            print(f"  harvester skip {url[:40]}: {e}")

    print(f"  📊 Email harvest: {total_found} وُجد | {total_queued} أُضيف للقائمة")


def email_sender_loop():
    """
    يُرسل من _email_queue بإيقاع بشري:
    - يتحقق من نافذة الإرسال (7 صباحاً → 11 مساءً)
    - تأخير عشوائي 10-40 ثانية بين كل إيميل
    - يحترم الحد اليومي المتدرج
    """
    print("📧 Email sender: بدأ")
    while True:
        try:
            cap = _email_daily_cap()
            sent = LOCAL_STATS.get("email", 0)
            if not _in_send_window():
                h = datetime.utcnow().hour
                log_activity("Email", "⏸ انتظار نافذة الإرسال", "SMTP",
                             note=f"الساعة {h} UTC — الإرسال متاح 07:00-23:00", level="warn")
                time.sleep(300)
                continue
            if sent >= cap:
                log_activity("Email", "⏸ وصل الحد اليومي", "SMTP",
                             note=f"{sent}/{cap} إيميل اليوم", level="warn")
                time.sleep(600)
                continue

            with _email_queue_lock:
                qsize = len(_email_queue)
            if qsize == 0:
                time.sleep(10)
                continue

            with _email_queue_lock:
                if not _email_queue:
                    pass
                else:
                    item = _email_queue.pop(0)
                    ok, msg = send_email(
                        item["to"], item["subject"], item["body"],
                        sender_name=_random_sender()
                    )
                    if ok:
                        memory.mark_user(item["email_id"])
                        memory.log("Email", item["title"], item["url"],
                                   f"→ {item['to']}", item["body"])
                        antiban.record("email")
                        LOCAL_STATS["emails_sent"] = LOCAL_STATS.get("emails_sent", 0) + 1
                        log_activity("Email", f"✉ إيميل أُرسل", item["to"],
                                     found=1,
                                     note=f"الموضوع: {item['subject'][:60]} | {sent+1}/{cap}",
                                     level="success")
                        log_sent_email(item["to"], item["subject"],
                                       item["body"], item["url"], item["title"])
                        print(f"✅ Email → {item['to']} (cap:{cap})")
                        time.sleep(random.uniform(10, 40))
                        continue
                    else:
                        log_activity("Email", "✗ فشل الإرسال", item["to"],
                                     note=msg, level="error")
                        print(f"  ✗ Email failed: {msg}")

        except Exception as e:
            log_activity("Email", "خطأ في المُرسِل", "SMTP",
                         note=str(e)[:80], level="error")
            print(f"Sender error: {e}")
        time.sleep(random.uniform(3, 8))


def email_harvester_loop():
    """يشغّل الحصّاد بشكل دوري لملء القائمة (بدون asyncio)."""
    cycle = 0
    while True:
        try:
            with _email_queue_lock:
                qsize = len(_email_queue)
            cycle += 1
            if qsize < 50:
                log_activity("Email", f"دورة حصاد #{cycle}", "DuckDuckGo",
                             note=f"القائمة {qsize} — يبدأ البحث", level="info")
                email_harvester()
            else:
                log_activity("Email", "⏸ القائمة ممتلئة", "Queue",
                             found=qsize,
                             note=f"{qsize} إيميل بانتظار الإرسال", level="warn")
        except Exception as e:
            log_activity("Email", "خطأ في الحصاد", "—",
                         note=str(e)[:80], level="error")
            print(f"  ❌ Harvester loop error: {e}")
        wait = random.randint(120, 300)
        time.sleep(wait)

# ==========================================
# 12b. مراقبة الردود على تعليقاتنا
# ==========================================

def replies_monitor_loop():
    """
    يراقب الردود على تعليقاتنا في GitHub وReddit كل 15 دقيقة.
    يسجّل أي رد جديد في REPLIES_LOG وعدادات الإحصائيات.
    """
    print("👁 Replies monitor: بدأ")
    gh_headers = {"Authorization": f"token {GITHUB_TOKEN}",
                  "Accept": "application/vnd.github.v3+json"}
    while True:
        try:
            # ── GitHub: تحقق من ردود على تعليقاتنا ──
            if GITHUB_TOKEN:
                with _our_comments_lock:
                    gh_snap = list(_our_github_comments[-30:])
                for rec in gh_snap:
                    try:
                        # جلب التعليقات على الـ issue
                        r = requests.get(
                            rec["repo_api"] + "/comments",
                            headers=gh_headers, timeout=10,
                        )
                        if r.status_code != 200:
                            continue
                        for c in r.json():
                            c_id  = str(c.get("id", ""))
                            c_key = f"ghreply:{c_id}"
                            if str(c_id) == str(rec["comment_id"]):
                                continue   # تعليقنا نفسه
                            if memory.seen(c_key):
                                continue
                            author = c.get("user", {}).get("login", "")
                            body   = (c.get("body") or "")
                            if not body.strip():
                                continue
                            # هل هو رد بعد تعليقنا؟
                            our_ts  = rec.get("ts", "")
                            c_ts    = c.get("created_at", "")
                            if our_ts and c_ts and c_ts < our_ts:
                                continue
                            memory.mark(c_key)
                            log_reply("GitHub", author, rec["title"],
                                      body, rec["url"])
                            log_activity("GitHub", "رد جديد على تعليقنا",
                                         rec["title"][:60],
                                         note=f"من @{author}: {body[:80]}",
                                         level="success")
                            print(f"  💬 GitHub reply from @{author} on: {rec['title'][:40]}")
                    except Exception as e:
                        print(f"  GitHub reply check error: {e}")

            # ── Reddit: تحقق من ردود على تعليقاتنا ──
            sess = _get_reddit_session()
            if sess:
                with _our_comments_lock:
                    rd_snap = list(_our_reddit_comments[-20:])
                for rec in rd_snap:
                    try:
                        # جلب تعليقات المنشور
                        post_json_url = rec["post_url"].rstrip("/") + ".json?limit=50"
                        r = sess.get(post_json_url, timeout=12)
                        if r.status_code != 200:
                            continue
                        data = r.json()
                        comments_listing = data[1].get("data", {}).get("children", []) if len(data) > 1 else []
                        for ch in comments_listing:
                            c = ch.get("data", {})
                            c_id  = c.get("name", "")
                            c_key = f"rdreply:{c_id}"
                            if memory.seen(c_key):
                                continue
                            author  = c.get("author", "")
                            body    = (c.get("body") or "")
                            if not body.strip() or author == "[deleted]":
                                continue
                            our_ts  = rec.get("ts", "")
                            c_ts_ut = c.get("created_utc", 0)
                            try:
                                c_ts = datetime.utcfromtimestamp(c_ts_ut).isoformat()
                                if our_ts and c_ts < our_ts:
                                    continue
                            except Exception:
                                pass
                            memory.mark(c_key)
                            log_reply("Reddit", author, rec["title"], body, rec["post_url"])
                            log_activity("Reddit", "رد جديد على تعليقنا",
                                         rec["title"][:60],
                                         note=f"من u/{author}: {body[:80]}",
                                         level="success")
                            print(f"  💬 Reddit reply from u/{author} on r/{rec.get('sub','')}")
                    except Exception as e:
                        print(f"  Reddit reply check error: {e}")

        except Exception as e:
            print(f"Replies monitor error: {e}")

        time.sleep(900)   # كل 15 دقيقة

def _print_keys_status():
    """يطبع حالة كل المفاتيح عند البدء."""
    print()
    print("━" * 50)
    print("🔑  فحص المفاتيح")
    print("━" * 50)
    keys = [
        ("NVIDIA_API_KEY",            NVIDIA_API_KEY,            "🤖 AI Engine",         True),
        ("GITHUB_TOKEN",              GITHUB_TOKEN,              "🐙 GitHub",             True),
        ("SMTP_EMAIL",                SMTP_EMAIL,                "📧 Email (From)",       True),
        ("SMTP_PASSWORD",             SMTP_PASSWORD,             "📧 Email (Password)",   True),
        ("UPSTASH_REDIS_REST_URL",    UPSTASH_REDIS_REST_URL,    "🧠 Redis Memory",       True),
        ("UPSTASH_REDIS_REST_TOKEN",  UPSTASH_REDIS_REST_TOKEN,  "🧠 Redis Token",        True),
        ("REDDIT_CLIENT_ID",          REDDIT_CLIENT_ID,          "🟠 Reddit Client ID",   True),
        ("REDDIT_CLIENT_SECRET",      REDDIT_CLIENT_SECRET,      "🟠 Reddit Secret",      True),
        ("REDDIT_USERNAME",           REDDIT_USERNAME,           "🟠 Reddit Username",    True),
        ("REDDIT_PASSWORD",           REDDIT_PASSWORD,           "🟠 Reddit Password",    True),
        ("DISCORD_BOT_TOKEN",         DISCORD_BOT_TOKEN,         "💬 Discord",            False),
        ("DEVTO_API_KEY",             DEVTO_API_KEY,             "📝 Dev.to",             False),
        ("PRODUCTHUNT_API_KEY",       PH_API_KEY,                "🚀 ProductHunt Key",    False),
        ("PRODUCTHUNT_API_SECRET",    PH_API_SECRET,             "🚀 ProductHunt Secret", False),
        ("STACKOVERFLOW_API_KEY",     SO_API_KEY,                "💻 StackOverflow",      False),
    ]
    all_ok = True
    for name, val, label, required in keys:
        has = bool(val)
        icon = "✅" if has else ("❌" if required else "⚪")
        status = "موجود" if has else ("مفقود!" if required else "اختياري")
        print(f"  {icon} {label:25s} {status}")
        if required and not has:
            all_ok = False
    print("━" * 50)
    if all_ok:
        print("✅ كل المفاتيح الإلزامية موجودة — البوت جاهز")
    else:
        print("⚠️  بعض المفاتيح الإلزامية مفقودة — بعض المنصات ستكون معطّلة")
    print("━" * 50)
    print()


def start_all():
    # ── اختبار SMTP فور البدء ──
    smtp_ok, smtp_msg = test_smtp_connection()
    print(f"{'✅' if smtp_ok else '❌'} SMTP: {smtp_msg}")
    if not smtp_ok:
        print("⚠️  الإيميلات لن تُرسل حتى يُصلح SMTP")

    # تحميل إحصائيات اليوم من Redis (تبقى بعد الـ restart)
    saved = memory.load_stats()
    if saved:
        for k, v in saved.items():
            if k in LOCAL_STATS:
                LOCAL_STATS[k] = v
        print(f"📊 إحصائيات اليوم محمّلة من Redis: {LOCAL_STATS}")

    _print_keys_status()

    threads = [
        threading.Thread(target=_keyword_refresh_loop,  daemon=True),
        threading.Thread(target=github_loop,            daemon=True),
        threading.Thread(target=reddit_loop,            daemon=True),
        threading.Thread(target=devto_loop,             daemon=True),
        threading.Thread(target=stackoverflow_loop,     daemon=True),
        threading.Thread(target=producthunt_loop,       daemon=True),
        threading.Thread(target=discord_monitor_loop,   daemon=True),
        threading.Thread(target=email_harvester_loop,   daemon=True),
        threading.Thread(target=email_sender_loop,      daemon=True),
        threading.Thread(target=replies_monitor_loop,   daemon=True),
    ]
    for t in threads:
        t.start()

    total = sum(LIMITS.values())
    print(f"🚀 Orgteh Marketing Engine — 8 منصات تعمل | الطاقة اليومية: {total:,} رسالة")

start_all()

# ==========================================
# 14. واجهة Gradio — لوحة تحكم كاملة
# ==========================================

def refresh_stats():
    with _keyword_lock:
        kw_count = len(_keyword_cache)
    last_refresh = (
        datetime.utcfromtimestamp(_last_keyword_refresh).strftime("%H:%M UTC")
        if _last_keyword_refresh else "لم يتم بعد"
    )
    s = LOCAL_STATS
    total_actions = (s.get("reddit",0) + s.get("github",0) + s.get("devto",0)
                     + s.get("stackoverflow",0) + s.get("producthunt",0)
                     + s.get("discord",0))
    with _email_queue_lock:
        q_now = len(_email_queue)
    return (
        s.get("reddit", 0),
        s.get("github", 0),
        s.get("email", 0),
        s.get("devto", 0),
        s.get("stackoverflow", 0),
        s.get("producthunt", 0),
        s.get("discord", 0),
        total_actions,
        s.get("emails_found", 0),
        s.get("emails_queued", 0),
        s.get("emails_sent", 0),
        q_now,
        s.get("replies_received", 0),
        f"{kw_count} كلمة | آخر تجديد: {last_refresh}",
    )


def refresh_activity_log():
    """سجل النشاط التفصيلي — كل عملية بحث وكل منصة."""
    with _activity_lock:
        logs = list(ACTIVITY_LOGS[:150])
    if not logs:
        return "⏳ البوت يعمل في الخلفية — لا نشاط مسجّل بعد..."
    lines = []
    for entry in logs:
        icon    = entry.get("icon", "🔎")
        ts      = entry.get("ts", "")
        plat    = entry.get("platform", "")
        action  = entry.get("action", "")
        site    = entry.get("site", "")
        found   = entry.get("found", 0)
        note    = entry.get("note", "")
        found_str = f" [{found}]" if found else ""
        lines.append(f"{icon} [{ts}] {plat} — {action}{found_str}")
        if site:
            lines.append(f"   📍 {site}")
        if note:
            lines.append(f"   💬 {note}")
        lines.append("")
    return "\n".join(lines)


def refresh_sent_emails():
    """سجل الإيميلات المرسلة."""
    with _activity_lock:
        logs = list(SENT_EMAILS_LOG[:80])
    if not logs:
        return "📭 لم يُرسل أي إيميل بعد..."
    lines = []
    for e in logs:
        lines.append("─" * 50)
        lines.append(f"🕐 {e.get('ts','')}  →  📧 {e.get('to','')}")
        lines.append(f"📌 الموضوع: {e.get('subject','')}")
        lines.append(f"🌐 المصدر: {e.get('url','')[:70]}")
        lines.append(f"📝 {e.get('body','')[:200]}")
        lines.append("")
    return "\n".join(lines)


def refresh_replies_log():
    """سجل الردود على تعليقاتنا ورسائلنا."""
    with _activity_lock:
        logs = list(REPLIES_LOG[:60])
    if not logs:
        return "📬 لا ردود مستلمة بعد — يراقب البوت كل 15 دقيقة..."
    lines = []
    for r in logs:
        lines.append("─" * 50)
        lines.append(f"🕐 {r.get('ts','')}  [{r.get('platform','')}]")
        lines.append(f"👤 من: {r.get('from_user','')}")
        lines.append(f"📤 تعليقنا: {r.get('our_content','')[:120]}")
        lines.append(f"💬 ردّه: {r.get('their_reply','')[:300]}")
        if r.get("url"):
            lines.append(f"🔗 {r.get('url','')[:80]}")
        lines.append("")
    return "\n".join(lines)


def refresh_interaction_log():
    """السجل الكلاسيكي للتفاعلات (تعليقات + ردود)."""
    logs = memory.load_logs()
    if not logs:
        return "لا يوجد نشاط بعد — البوت يعمل في الخلفية..."
    lines = []
    for log in list(reversed(logs))[:60]:
        lines.append("─" * 45)
        lines.append(f"{log.get('ts','')}  [{log.get('platform','')}]")
        lines.append(log.get("title", ""))
        if log.get("url"):
            lines.append(log.get("url", ""))
        lines.append(log.get("reply", "")[:250])
        lines.append("")
    return "\n".join(lines)


ICON_MAP = {
    "reddit":       "🟠",
    "github":       "🐙",
    "email":        "📧",
    "devto":        "📝",
    "stackoverflow":"💻",
    "producthunt":  "🚀",
    "discord":      "💬",
}

CSS = """
.stat-card { border-radius: 10px; padding: 6px; text-align: center; }
.gr-number input { font-size: 1.4em; font-weight: bold; text-align: center; }
"""

with gr.Blocks(title="Orgteh Marketing Engine") as demo:

    gr.Markdown(
        "# 🚀 Orgteh Marketing Engine\n"
        "**الموقع:** orgteh.com &nbsp;|&nbsp; "
        "**المنصات:** 🐙 GitHub · 🟠 Reddit · 📝 Dev.to · 💻 StackOverflow · "
        "🚀 ProductHunt · 💬 Discord · 📧 Email"
    )

    # ── صف الإحصائيات الرئيسية ──
    with gr.Row():
        r_reddit  = gr.Number(label="🟠 Reddit",       min_width=80)
        r_github  = gr.Number(label="🐙 GitHub",       min_width=80)
        r_email   = gr.Number(label="📧 Email مُرسَل", min_width=80)
        r_devto   = gr.Number(label="📝 Dev.to",       min_width=80)
        r_so      = gr.Number(label="💻 StackOverflow",min_width=80)
        r_ph      = gr.Number(label="🚀 ProductHunt",  min_width=80)
        r_discord = gr.Number(label="💬 Discord DMs",  min_width=80)

    # ── صف إحصائيات الإيميل التفصيلية ──
    with gr.Row():
        r_total        = gr.Number(label="📊 إجمالي الإجراءات اليوم", min_width=100)
        r_found        = gr.Number(label="🔍 إيميلات وُجدت",           min_width=100)
        r_queued       = gr.Number(label="📥 في قائمة الانتظار",       min_width=100)
        r_sent         = gr.Number(label="✉ إيميلات أُرسلت",           min_width=100)
        r_queue_now    = gr.Number(label="⏳ بانتظار الإرسال الآن",    min_width=100)
        r_replies      = gr.Number(label="💬 ردود مستلمة",             min_width=100)
        r_keywords     = gr.Textbox(label="🔑 كلمات البحث",            interactive=False, min_width=160)

    with gr.Row():
        refresh_btn   = gr.Button("🔄 تحديث الكل", variant="primary", size="lg")
        copy_all_btn  = gr.Button("📋 نسخ كل السجلات", variant="secondary", size="lg")
        smtp_test_btn = gr.Button("🔌 اختبار SMTP", variant="secondary", size="lg")
        send_test_btn = gr.Button("✉ إرسال إيميل تجريبي", variant="secondary", size="lg")

    smtp_status_box = gr.Textbox(
        label="🔌 حالة SMTP",
        value="اضغط 'اختبار SMTP' للتحقق",
        interactive=False,
    )
    test_email_input = gr.Textbox(
        label="✉ إيميلك لاستقبال الإيميل التجريبي",
        placeholder="your@email.com",
        interactive=True,
    )
    test_email_result = gr.Textbox(
        label="نتيجة الإرسال التجريبي",
        interactive=False,
    )

    copy_all_box = gr.Textbox(
        label="📋 انسخ من هنا (كل السجلات مجمّعة)",
        lines=4, interactive=True, visible=False,
        placeholder="اضغط 'نسخ كل السجلات' أولاً..."
    )

    # ── التبويبات ──
    with gr.Tabs():

        with gr.Tab("📋 سجل النشاط التفصيلي"):
            gr.Markdown(
                "كل عملية بحث لكل منصة — يُظهر كم إيميل وجد، أي موقع زاره، "
                "هل نجح التعليق أم لا"
            )
            with gr.Row():
                copy_activity_btn = gr.Button("📋 نسخ السجل", size="sm")
            activity_view = gr.Textbox(
                label="النشاط الحي", lines=30, max_lines=50,
                interactive=False
            )

        with gr.Tab("✅ التفاعلات المُنجزة"):
            gr.Markdown("التعليقات والردود التي أرسلها البوت بنجاح على جميع المنصات")
            with gr.Row():
                copy_interaction_btn = gr.Button("📋 نسخ السجل", size="sm")
            interaction_view = gr.Textbox(
                label="سجل التفاعلات", lines=30, max_lines=50,
                interactive=False
            )

        with gr.Tab("✉ الإيميلات المُرسَلة"):
            gr.Markdown(
                "كل إيميل أُرسل: الوجهة، الموضوع، نص الرسالة، مصدر الإيميل"
            )
            with gr.Row():
                copy_sent_btn = gr.Button("📋 نسخ السجل", size="sm")
            sent_emails_view = gr.Textbox(
                label="الإيميلات المرسلة", lines=30, max_lines=50,
                interactive=False
            )

        with gr.Tab("💬 الردود الواردة"):
            gr.Markdown(
                "ردود المستخدمين على تعليقاتنا في GitHub وReddit — "
                "يُحدَّث كل 15 دقيقة تلقائياً"
            )
            with gr.Row():
                copy_replies_btn = gr.Button("📋 نسخ السجل", size="sm")
            replies_view = gr.Textbox(
                label="الردود على تعليقاتنا", lines=30, max_lines=50,
                interactive=False
            )

    # ── ربط الأزرار والتحميل ──
    stats_outs = [
        r_reddit, r_github, r_email, r_devto, r_so, r_ph, r_discord,
        r_total, r_found, r_queued, r_sent, r_queue_now, r_replies, r_keywords,
    ]

    # ── وظيفة نسخ النص (تُعيد النص كاملاً لعنصر مؤقت قابل للنسخ) ──
    def get_all_logs():
        """يجمع كل السجلات في نص واحد للنسخ."""
        parts = [
            "═══ سجل النشاط ═══", refresh_activity_log(),
            "\n═══ التفاعلات المُنجزة ═══", refresh_interaction_log(),
            "\n═══ الإيميلات المُرسَلة ═══", refresh_sent_emails(),
            "\n═══ الردود الواردة ═══", refresh_replies_log(),
        ]
        return "\n".join(parts)

    copy_all_out = gr.Textbox(label="📋 كل السجلات (للنسخ)", lines=5,
                               interactive=True, visible=False)
    copy_activity_btn.click(refresh_activity_log,    outputs=[copy_all_out])
    copy_interaction_btn.click(refresh_interaction_log, outputs=[copy_all_out])
    copy_sent_btn.click(refresh_sent_emails,          outputs=[copy_all_out])
    copy_replies_btn.click(refresh_replies_log,       outputs=[copy_all_out])

    refresh_btn.click(refresh_stats,           outputs=stats_outs)
    refresh_btn.click(refresh_activity_log,    outputs=[activity_view])
    refresh_btn.click(refresh_interaction_log, outputs=[interaction_view])
    refresh_btn.click(refresh_sent_emails,     outputs=[sent_emails_view])
    refresh_btn.click(refresh_replies_log,     outputs=[replies_view])

    # ── زر نسخ كل السجلات ──
    def collect_all_logs():
        parts = [
            "═" * 50,
            "  سجل النشاط التفصيلي",
            "═" * 50,
            refresh_activity_log(),
            "",
            "═" * 50,
            "  التفاعلات المُنجزة",
            "═" * 50,
            refresh_interaction_log(),
            "",
            "═" * 50,
            "  الإيميلات المُرسَلة",
            "═" * 50,
            refresh_sent_emails(),
            "",
            "═" * 50,
            "  الردود الواردة",
            "═" * 50,
            refresh_replies_log(),
        ]
        return gr.update(value="\n".join(parts), visible=True)

    copy_all_btn.click(collect_all_logs, outputs=[copy_all_box])

    # ── اختبار SMTP ──
    def run_smtp_test():
        ok, msg = test_smtp_connection()
        with _email_queue_lock:
            q = len(_email_queue)
        cap = _email_daily_cap()
        sent = LOCAL_STATS.get("email", 0)
        status = (
            f"{msg}\n"
            f"{'─'*40}\n"
            f"قائمة الانتظار: {q} إيميل\n"
            f"مُرسَل اليوم: {sent}/{cap}\n"
            f"نافذة الإرسال: {'✅ مفتوحة' if _in_send_window() else '⏸ مغلقة'}\n"
            f"إيميلات مكتشفة: {LOCAL_STATS.get('emails_found',0)}\n"
            f"إيميلات في القائمة (مجموع): {LOCAL_STATS.get('emails_queued',0)}"
        )
        return status

    smtp_test_btn.click(run_smtp_test, outputs=[smtp_status_box])

    # ── إيميل تجريبي ──
    def send_test_email_fn(to_addr):
        if not to_addr or "@" not in to_addr:
            return "❌ أدخل إيميلاً صحيحاً"
        ok, msg = test_smtp_connection()
        if not ok:
            return f"❌ SMTP فشل أولاً: {msg}"
        subject = "✅ اختبار من Orgteh Marketing Engine"
        body = (
            "هذا إيميل تجريبي لاختبار نظام الإرسال.\n\n"
            f"الوقت: {datetime.utcnow().strftime('%Y-%m-%d %H:%M UTC')}\n"
            f"الخادم: {SMTP_SERVER}:{SMTP_PORT}\n"
            f"المُرسِل: {SMTP_EMAIL}\n\n"
            "إذا وصلك هذا الإيميل فنظام الإرسال يعمل بشكل صحيح."
        )
        ok2, msg2 = send_email(to_addr, subject, body, sender_name="Orgteh Test")
        if ok2:
            return f"✅ أُرسل بنجاح إلى {to_addr} — تحقق من صندوق الوارد"
        return f"❌ فشل الإرسال: {msg2}"

    send_test_btn.click(send_test_email_fn,
                        inputs=[test_email_input],
                        outputs=[test_email_result])

    demo.load(refresh_stats,           outputs=stats_outs)
    demo.load(refresh_activity_log,    outputs=[activity_view])
    demo.load(refresh_interaction_log, outputs=[interaction_view])
    demo.load(refresh_sent_emails,     outputs=[sent_emails_view])
    demo.load(refresh_replies_log,     outputs=[replies_view])


if __name__ == "__main__":
    demo.launch(server_name="0.0.0.0", server_port=7860,
                css=CSS, theme=gr.themes.Soft())