Upload 3 files

Dockerfile

@@ -1,10 +1,7 @@
 FROM python:3.11-slim
 
-# tesseract مطلوب لقراءة الأرقام من صور الحسابات (الليفل / الجواهر)
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    tesseract-ocr \
-    tesseract-ocr-ara \
-    && rm -rf /var/lib/apt/lists/*
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
 
 WORKDIR /app
 
@@ -13,12 +10,7 @@ RUN pip install --no-cache-dir -r requirements.txt
 
 COPY main.py .
 
-# مجلد الجلسات (telethon سيشن للـ user client والـ bot client) لازم يكون
-# على volume دائم عشان ما يطلب تسجيل دخول من جديد كل مرة يعاد تشغيل الحاوية
-VOLUME ["/app/session"]
-ENV TELEGRAM_SESSION=/app/session/bounty_bot
-
-# لازم تمرر وقت التشغيل: TELEGRAM_API_ID, TELEGRAM_API_HASH, BOT_TOKEN,
-# OWNER_ID (افتراضي 6069597294), MONGO_URI
+# Writable dir for the Telethon session file (HF Spaces containers run as non-root by default)
+RUN mkdir -p /app/data && chmod -R 777 /app
 
 CMD ["python", "main.py"]

main.py

@@ -1,661 +1,1563 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 """
-main.py
--------
-بوت تسعير حسابات Bounty Rush - مركزي، يستخدمه مالك واحد بس (OWNER_ID).
-
-كل الاتصال بتيليجرام عبر Telethon (MTProto خالص، بدون aiogram أو أي
-مكتبة Bot API عبر HTTP).
-
-فكرة العمل:
-- bot_client: بوت تيليجرام حقيقي (BOT_TOKEN من BotFather) تكلمه أنت وتضغط
-  أزراره. مقفول عليك بس (OWNER_ID).
-- حسابات المراقبة (Monitoring Accounts): حسابات تيليجرام عادية (أرقام
-  هواتف) تنضاف *من داخل البوت نفسه* (بدون أي سكريبت خارجي أو طرفية) -
-  تكتب رقم الهاتف بالشات، يوصلك كود تكتبه بالشات، وخلاص. تقدر تضيف أكثر
-  من حساب مراقبة وحدة، وكل قناة تنضاف توزع تلقائيًا (round-robin) على
-  حساب مراقبة معين يتكفل بمراقبتها وسحب تاريخها.
-
-جلسات حسابات المراقبة تنخزن كـ نص (StringSession) داخل MongoDB نفسها -
-ما تحتاج أي ملف جلسة ولا volume خاص فيها، كل شي مركزي بقاعدة البيانات.
-
-أزرار /start:
-  📖 الشرح
-  👤 إضافة حساب مراقبة     -> يبدأ محادثة: رقم الهاتف -> كود التحقق ->
-                              (كلمة سر لو عندك تحقق بخطوتين) -> يضيف
-                              الحساب كحساب مراقبة جديد.
-  ➕ إضافة قناة مراقبة       -> يطلب يوزر القناة، يوزعها على أحد حسابات
-                              المراقبة المضافة (لازم يكون عندك حساب
-                              مراقبة واحد على الأقل).
-  📅 تعيين تاريخ المراقبة    -> يطلب تاريخ بصيغة YYYY|MM|DD، ويبدأ يسحب
-                              كل منشور فيه صورة وسعر من كل القنوات
-                              المضافة، من هذا التاريخ لليوم.
-  🎯 تقييم حساب             -> يطلب صورة سكرين شوت، ويرد بسعر تقريبي.
-
-المتغيرات المطلوبة (بيئة التشغيل):
-  TELEGRAM_API_ID     - من my.telegram.org
-  TELEGRAM_API_HASH   - من my.telegram.org
-  TELEGRAM_SESSION    - مسار ملف جلسة البوت فقط (افتراضي: /app/session/bounty_bot)
-  BOT_TOKEN           - توكن بوت من @BotFather (يسجل دخول عبر MTProto مباشرة)
-  OWNER_ID            - آيدي المستخدم المسموح له وحده يستخدم البوت (افتراضي: 6069597294)
-  MONGO_URI           - رابط اتصال MongoDB
-  MONGO_DB_NAME       - اسم قاعدة البيانات (افتراضي: bounty_pricer)
-  SIMILARITY_TOP_K    - عدد أقرب النتائج بحساب متوسط السعر (افتراضي: 5)
-
-ملاحظة: bot_client فقط يحتاج ملف جلسة على volume (تسجيل دخوله بتوكن،
-ما يحتاج تفاعل بشري). حسابات المراقبة كلها تنضاف وتنخزن عبر المحادثة
-داخل MongoDB، فما فيه أي حاجة لطرفية تفاعلية أو سكريبت خارجي.
+MF BLACKLIST - Telegram Bot (Telethon + MTProto + MongoDB + asyncio)
+Production-ready single-file implementation.
 """
 
 import os
-import re
-import io
-import asyncio
+import sys
+import time
 import logging
-from datetime import datetime, timezone
-
-import numpy as np
-from PIL import Image
-import pytesseract
-import torch
-import open_clip
-from pymongo import MongoClient, ReturnDocument
+import asyncio
+import datetime
+from collections import defaultdict
 
 from telethon import TelegramClient, events, Button
-from telethon.sessions import StringSession
-from telethon.tl.functions.channels import JoinChannelRequest
 from telethon.errors import (
-    SessionPasswordNeededError,
-    PhoneCodeInvalidError,
-    PhoneCodeExpiredError,
-    PasswordHashInvalidError,
-    FloodWaitError,
+    FloodWaitError, RPCError, UsernameNotOccupiedError, UsernameInvalidError,
+    UserIdInvalidError, ChatAdminRequiredError, ChannelPrivateError,
+    UserNotParticipantError, PeerIdInvalidError,
+)
+from telethon.tl.types import User, Channel, Chat, PeerChannel
+
+from motor.motor_asyncio import AsyncIOMotorClient
+from pymongo import ASCENDING, DESCENDING
+from pymongo.errors import PyMongoError
+
+# ─────────────────────────────────────────────────────────────────────────
+# Logging
+# ────────────────────────────────────────────────────────────────────���────
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
 )
+log = logging.getLogger("mfblacklist")
+logging.getLogger("telethon").setLevel(logging.WARNING)
+
+# ─────────────────────────────────────────────────────────────────────────
+# Environment variables
+# ─────────────────────────────────────────────────────────────────────────
+def _require_env(name: str) -> str:
+    val = os.environ.get(name)
+    if not val or not val.strip():
+        log.error("Missing required environment variable: %s", name)
+        sys.exit(1)
+    return val.strip()
+
+API_ID_RAW = _require_env("API_ID")
+API_HASH = _require_env("API_HASH")
+BOT_TOKEN = _require_env("BOT_TOKEN")
+MONGO_URI = _require_env("MONGO_URI")
+
+try:
+    API_ID = int(API_ID_RAW)
+except ValueError:
+    log.error("API_ID must be an integer")
+    sys.exit(1)
+
+OWNER_ID = 6069597294  # fixed, cannot be changed from the bot panel
+
+# ─────────────────────────────────────────────────────────────────────────
+# Mongo
+# ─────────────────────────────────────────────────────────────────────────
+mongo_client = AsyncIOMotorClient(MONGO_URI)
+db = mongo_client["mf_blacklist"]
+
+col_admins = db["admins"]
+col_cases = db["cases"]
+col_users = db["users"]
+col_settings = db["settings"]
+col_logs = db["logs"]
+col_pending = db["pending_reports"]
+col_counters = db["counters"]
+
+ALL_PERMISSIONS = [
+    "approve_reports",
+    "reject_reports",
+    "manage_reports",
+    "edit_templates",
+    "manage_settings",
+    "manage_admins",
+]
 
-logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
-log = logging.getLogger("bounty_bot")
-
-# ---------------------------------------------------------------------------
-# الإعدادات
-# ---------------------------------------------------------------------------
-API_ID = int(os.environ["TELEGRAM_API_ID"])
-API_HASH = os.environ["TELEGRAM_API_HASH"]
-BOT_SESSION_PATH = os.environ.get("TELEGRAM_SESSION", "bounty_bot")
-
-BOT_TOKEN = os.environ["BOT_TOKEN"]
-OWNER_ID = int(os.environ.get("OWNER_ID", "6069597294"))
-
-MONGO_URI = os.environ["MONGO_URI"]
-MONGO_DB_NAME = os.environ.get("MONGO_DB_NAME", "bounty_pricer")
-TOP_K = int(os.environ.get("SIMILARITY_TOP_K", "5"))
-
-# ---------------------------------------------------------------------------
-# MongoDB
-# ---------------------------------------------------------------------------
-mongo_client = MongoClient(MONGO_URI)
-db = mongo_client[MONGO_DB_NAME]
-listings = db["listings"]        # كل وثيقة = إعلان/حساب (صورة محللة + سعر + بصمة)
-channels_col = db["channels"]    # القنوات المضافة + الحساب المسؤول عن كل وحدة
-accounts_col = db["accounts"]    # حسابات المراقبة (StringSession مخزنة بقاعدة البيانات)
-config_col = db["config"]        # إعدادات عامة (تاريخ بداية المراقبة، عداد التوزيع)
-
-# ---------------------------------------------------------------------------
-# نموذج CLIP (بصمة بصرية مجانية، بدون API key) + OCR
-# ---------------------------------------------------------------------------
-_DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-log.info("تحميل نموذج CLIP على %s ...", _DEVICE)
-_CLIP_MODEL, _, _CLIP_PREPROCESS = open_clip.create_model_and_transforms(
-    "ViT-B-32", pretrained="openai"
+DEFAULT_TEMPLATE_THIEF = (
+    "🚨 بلاغ سارق\n\n"
+    "👤 المستخدم: {username}\n"
+    "🆔 ID: {user_id}\n\n"
+    "📋 التفاصيل:\n{description}\n\n"
+    "🔖 رقم البلاغ: {case_id}\n"
+    "📅 التاريخ: {date}"
+)
+DEFAULT_TEMPLATE_IMPERSONATOR = (
+    "⚠️ بلاغ منتحل\n\n"
+    "👤 المستخدم: {username}\n"
+    "🆔 ID: {user_id}\n\n"
+    "📋 التفاصيل:\n{description}\n\n"
+    "🔖 رقم البلاغ: {case_id}\n"
+    "📅 التاريخ: {date}"
 )
-_CLIP_MODEL.eval().to(_DEVICE)
-log.info("تم تحميل نموذج CLIP.")
 
+TYPE_LABEL = {"thief": "سارق", "impersonator": "منتحل"}
 
-def get_image_embedding(image: Image.Image) -> np.ndarray:
-    image = image.convert("RGB")
-    tensor = _CLIP_PREPROCESS(image).unsqueeze(0).to(_DEVICE)
-    with torch.no_grad():
-        features = _CLIP_MODEL.encode_image(tensor)
-        features = features / features.norm(dim=-1, keepdim=True)
-    return features.cpu().numpy().flatten()
+# ─────────────────────────────────────────────────────────────────────────
+# In-memory conversation state & anti-spam
+# ─────────────────────────────────────────────────────────────────────────
+STATE = {}                       # user_id -> dict(flow, step, data)
+LAST_ACTION_TS = defaultdict(float)   # user_id -> timestamp (cooldown)
+ACTION_WINDOW = defaultdict(list)     # user_id -> list[timestamps] (flood window)
 
+COOLDOWN_SECONDS = 15
+MAX_ACTIONS_PER_WINDOW = 8
+WINDOW_SECONDS = 60
+STATE_TTL_SECONDS = 1800  # stale state cleanup
 
-def cosine_similarity(a, b) -> float:
-    a = np.array(a, dtype=np.float32)
-    b = np.array(b, dtype=np.float32)
-    denom = np.linalg.norm(a) * np.linalg.norm(b)
-    if denom == 0:
-        return 0.0
-    return float(np.dot(a, b) / denom)
 
+def clear_state(user_id: int):
+    STATE.pop(user_id, None)
 
-LEVEL_KEYWORDS = ["level", "lv", "lvl", "ليفل", "مستوى"]
-GEMS_KEYWORDS = ["gem", "gems", "جوهر", "جواهر", "الماس"]
 
+def set_state(user_id: int, flow: str, step: str, data: dict = None):
+    STATE[user_id] = {
+        "flow": flow,
+        "step": step,
+        "data": data or {},
+        "ts": time.time(),
+    }
 
-def ocr_extract_text(image: Image.Image) -> str:
-    try:
-        return pytesseract.image_to_string(image, lang="eng+ara")
-    except Exception:
-        return pytesseract.image_to_string(image, lang="eng")
-
-
-def _find_number_near_keyword(text: str, keywords):
-    for line in text.lower().splitlines():
-        for kw in keywords:
-            if kw in line:
-                numbers = re.findall(r"\d[\d,]*", line)
-                if numbers:
-                    try:
-                        return int(numbers[0].replace(",", ""))
-                    except ValueError:
-                        continue
-    return None
 
+def get_state(user_id: int):
+    st = STATE.get(user_id)
+    if not st:
+        return None
+    if time.time() - st["ts"] > STATE_TTL_SECONDS:
+        clear_state(user_id)
+        return None
+    return st
 
-def extract_specs_from_image(image: Image.Image) -> dict:
-    text = ocr_extract_text(image)
-    return {
-        "level": _find_number_near_keyword(text, LEVEL_KEYWORDS),
-        "gems": _find_number_near_keyword(text, GEMS_KEYWORDS),
-        "ocr_text": text.strip()[:500],
-    }
 
+def touch_state(user_id: int):
+    if user_id in STATE:
+        STATE[user_id]["ts"] = time.time()
 
-def extract_price_from_text(text: str):
-    if not text:
-        return None
-    text_l = text.lower()
-    patterns = [
-        r"\$\s?(\d[\d,\.]*)",
-        r"(\d[\d,\.]*)\s?\$",
-        r"(\d[\d,\.]*)\s?(?:دولار|usd)",
-        r"(\d[\d,\.]*)\s?(?:دينار|iqd)",
-    ]
-    for p in patterns:
-        m = re.search(p, text_l)
-        if m:
-            try:
-                return float(m.group(1).replace(",", ""))
-            except ValueError:
-                continue
-    return None
 
+def check_flood(user_id: int) -> bool:
+    """Return True if user is allowed to act now."""
+    now = time.time()
+    window = ACTION_WINDOW[user_id]
+    while window and now - window[0] > WINDOW_SECONDS:
+        window.pop(0)
+    if len(window) >= MAX_ACTIONS_PER_WINDOW:
+        return False
+    window.append(now)
+    return True
+
+
+def check_cooldown(user_id: int) -> float:
+    """Return remaining cooldown seconds (0 if OK) for starting a new report."""
+    last = LAST_ACTION_TS.get(user_id, 0)
+    elapsed = time.time() - last
+    if elapsed < COOLDOWN_SECONDS:
+        return COOLDOWN_SECONDS - elapsed
+    return 0
+
+
+def mark_action(user_id: int):
+    LAST_ACTION_TS[user_id] = time.time()
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Telethon client (runs as a bot account, not a user account)
+# ─────────────────────────────────────────────────────────────────────────
+SESSION_NAME = "mfblacklist_bot_session"
+client = TelegramClient(SESSION_NAME, API_ID, API_HASH)
 
-def find_similar_and_price(embedding: np.ndarray, specs: dict) -> dict:
-    all_docs = list(listings.find({"price": {"$ne": None}, "embedding": {"$exists": True}}))
-    if not all_docs:
-        return {"matches": [], "estimated_price": None}
-
-    scored = []
-    for doc in all_docs:
-        visual_sim = cosine_similarity(embedding, doc["embedding"])
-        numeric_bonus, numeric_count = 0.0, 0
-        if specs.get("level") is not None and doc.get("level") is not None:
-            diff = abs(specs["level"] - doc["level"])
-            numeric_bonus += max(0.0, 1 - diff / max(specs["level"], doc["level"], 1))
-            numeric_count += 1
-        if specs.get("gems") is not None and doc.get("gems") is not None:
-            diff = abs(specs["gems"] - doc["gems"])
-            numeric_bonus += max(0.0, 1 - diff / max(specs["gems"], doc["gems"], 1))
-            numeric_count += 1
-        final_score = (
-            0.6 * visual_sim + 0.4 * (numeric_bonus / numeric_count)
-            if numeric_count > 0
-            else visual_sim
+
+# ─────────────────────────────────────────────────────────────────────────
+# Helpers: safe telegram calls with FloodWait handling
+# ─────────────────────────────────────────────────────────────────────────
+async def safe_call(coro_factory, *args, retries=3, **kwargs):
+    """coro_factory: a callable returning a coroutine (so it can be retried)."""
+    for attempt in range(retries):
+        try:
+            return await coro_factory(*args, **kwargs)
+        except FloodWaitError as e:
+            wait_for = e.seconds + 1
+            log.warning("FloodWait: sleeping for %s seconds", wait_for)
+            await asyncio.sleep(wait_for)
+        except RPCError as e:
+            log.error("RPCError in safe_call: %s", e)
+            raise
+    raise RuntimeError("safe_call: exceeded retries after repeated FloodWait")
+
+
+async def log_action(user_id, action, details=None, case_id=None):
+    try:
+        await col_logs.insert_one({
+            "user_id": user_id,
+            "action": action,
+            "case_id": case_id,
+            "details": details or {},
+            "timestamp": datetime.datetime.utcnow(),
+        })
+    except PyMongoError as e:
+        log.error("Failed to write log entry: %s", e)
+
+
+async def upsert_user(user_id, username=None, first_name=None):
+    try:
+        await col_users.update_one(
+            {"user_id": user_id},
+            {"$set": {
+                "user_id": user_id,
+                "username": username,
+                "first_name": first_name,
+                "last_seen": datetime.datetime.utcnow(),
+            },
+             "$setOnInsert": {"first_seen": datetime.datetime.utcnow()}},
+            upsert=True,
         )
-        scored.append((final_score, doc))
-
-    scored.sort(key=lambda x: x[0], reverse=True)
-    top = scored[:TOP_K]
-    if not top:
-        return {"matches": [], "estimated_price": None}
-
-    weights = [max(s, 0.0001) for s, _ in top]
-    prices = [d["price"] for _, d in top]
-    estimated_price = sum(w * p for w, p in zip(weights, prices)) / sum(weights)
-
-    matches = [
-        {
-            "similarity_percent": round(s * 100, 1),
-            "price": d["price"],
-            "level": d.get("level"),
-            "gems": d.get("gems"),
-            "source_channel": d.get("source_channel"),
-        }
-        for s, d in top
-    ]
-    return {"matches": matches, "estimated_price": round(estimated_price, 2)}
+    except PyMongoError as e:
+        log.error("upsert_user failed: %s", e)
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Permissions
+# ─────────────────────────────────────────────────────────────────────────
+def is_owner(user_id: int) -> bool:
+    return user_id == OWNER_ID
+
 
+async def get_admin_doc(user_id: int):
+    if is_owner(user_id):
+        return {
+            "user_id": OWNER_ID,
+            "owner": True,
+            "permissions": {p: True for p in ALL_PERMISSIONS},
+        }
+    return await col_admins.find_one({"user_id": user_id})
 
-# ---------------------------------------------------------------------------
-# عميل البوت (bot_client) - MTProto، تسجيل دخول بتوكن، بدون أي تفاعل بشري
-# ---------------------------------------------------------------------------
-bot_client = TelegramClient(BOT_SESSION_PATH, API_ID, API_HASH)
 
-# حسابات المراقبة الفعّالة حاليًا: phone -> TelegramClient (StringSession)
-active_accounts: dict[str, TelegramClient] = {}
-background_tasks: list[asyncio.Task] = []
+async def is_admin(user_id: int) -> bool:
+    if is_owner(user_id):
+        return True
+    doc = await col_admins.find_one({"user_id": user_id})
+    return doc is not None
 
 
-async def process_message_for_storage(message, channel_username: str) -> bool:
-    """يحلل رسالة (صور�� + كابشن) ويخزنها بـ Mongo لو فيها سعر واضح. يرجع True لو خزن."""
-    if not message.photo:
-        return False
-    caption = message.message or ""
-    price = extract_price_from_text(caption)
-    if price is None:
+async def has_permission(user_id: int, perm: str) -> bool:
+    if is_owner(user_id):
+        return True
+    doc = await col_admins.find_one({"user_id": user_id})
+    if not doc:
         return False
+    return bool(doc.get("permissions", {}).get(perm, False))
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Settings helpers
+# ─────────────────────────────────────────────────────────────────────────
+async def get_settings():
+    doc = await col_settings.find_one({"_id": "config"})
+    if not doc:
+        doc = {
+            "_id": "config",
+            "reports_enabled": True,
+            "search_enabled": True,
+            "maintenance_message": "",
+            "channel_id": None,
+            "channel_username": None,
+            "review_group_id": None,
+            "template_thief": DEFAULT_TEMPLATE_THIEF,
+            "template_impersonator": DEFAULT_TEMPLATE_IMPERSONATOR,
+        }
+        await col_settings.insert_one(doc)
+    return doc
 
-    image_bytes = await message.download_media(file=bytes)
-    image = Image.open(io.BytesIO(image_bytes))
-
-    specs = extract_specs_from_image(image)
-    embedding = get_image_embedding(image)
-
-    doc = {
-        "source_channel": channel_username,
-        "message_id": message.id,
-        "date": datetime.now(timezone.utc),
-        "raw_text": caption,
-        "price": price,
-        "level": specs["level"],
-        "gems": specs["gems"],
-        "ocr_text": specs["ocr_text"],
-        "embedding": embedding.tolist(),
-    }
-    listings.update_one(
-        {"source_channel": channel_username, "message_id": message.id},
-        {"$set": doc},
+
+async def update_settings(fields: dict):
+    await col_settings.update_one({"_id": "config"}, {"$set": fields}, upsert=True)
+
+
+async def next_case_id() -> str:
+    doc = await col_counters.find_one_and_update(
+        {"_id": "case_seq"},
+        {"$inc": {"seq": 1}},
         upsert=True,
+        return_document=True,
     )
-    return True
+    seq = doc["seq"] if doc else 1
+    return f"MF-{seq:06d}"
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Keyboards
+# ─────────────────────────────────────────────────────────────────────────
+async def main_menu_buttons(user_id: int):
+    rows = [
+        [Button.inline("🔍 البحث عن شخص", b"search:start")],
+        [Button.inline("🚨 نشر سارق", b"report:thief:start")],
+        [Button.inline("⚠️ نشر منتحل", b"report:impersonator:start")],
+        [Button.inline("📖 شرح البوت", b"help:show")],
+        [Button.inline("📢 قناة النشر", b"channel:show")],
+    ]
+    if await is_admin(user_id):
+        rows.append([Button.inline("🛠 لوحة المطورين", b"admin:panel")])
+    return rows
 
 
-def _make_live_handler(channel_username: str):
-    async def handler(event):
-        try:
-            await process_message_for_storage(event.message, channel_username)
-        except Exception:
-            log.exception("خطأ أثناء معالجة رسالة مباشرة من %s", channel_username)
-    return handler
+def back_cancel_row(back_cb: bytes = b"menu:main"):
+    return [Button.inline("🔙 رجوع", back_cb), Button.inline("❌ إلغاء", b"flow:cancel")]
 
 
-async def register_channel_monitor(client: TelegramClient, channel_username: str):
-    """ينضم للقناة (لو قدر) ويسجل مراقبة لحظية عليها عن طريق حساب مراقبة معين."""
+# ─────────────────────────────────────────────────────────────────────────
+# Entity resolution helpers
+# ─────────────────────────────────────────────────────────────────────────
+async def resolve_username(username: str):
+    username = username.lstrip("@").strip()
     try:
-        await client(JoinChannelRequest(channel_username))
-    except Exception:
-        log.warning("ما كدرت أنضم لقناة %s بهذا الحساب (خاصة أو منضم أصلاً)", channel_username)
-
-    handler = _make_live_handler(channel_username)
-    client.add_event_handler(handler, events.NewMessage(chats=channel_username))
-    log.info("بدأت مراقبة القناة: %s", channel_username)
+        entity = await client.get_entity(username)
+        if isinstance(entity, User):
+            return entity
+        return None
+    except (UsernameNotOccupiedError, UsernameInvalidError, ValueError):
+        return None
+    except FloodWaitError as e:
+        await asyncio.sleep(e.seconds + 1)
+        return await resolve_username(username)
+    except RPCError as e:
+        log.warning("resolve_username RPCError: %s", e)
+        return None
 
 
-async def backfill_channel(client: TelegramClient, channel_username: str, start_date: datetime):
-    """يسحب كل المنشورات (فيها صورة وسعر) من تاريخ معين لليوم."""
-    count = 0
+async def resolve_user_id(uid: int):
     try:
-        async for message in client.iter_messages(
-            channel_username, offset_date=start_date, reverse=True
-        ):
-            try:
-                stored = await process_message_for_storage(message, channel_username)
-                if stored:
-                    count += 1
-            except Exception:
-                log.exception("خطأ بمعالجة رسالة قديمة من %s", channel_username)
-    except Exception:
-        log.exception("فشل سحب تاريخ القناة %s", channel_username)
-        await bot_client.send_message(OWNER_ID, f"⚠️ صار خطأ بسحب قناة {channel_username}")
-        return
+        entity = await client.get_entity(uid)
+        if isinstance(entity, User):
+            return entity
+        return None
+    except FloodWaitError as e:
+        await asyncio.sleep(e.seconds + 1)
+        return await resolve_user_id(uid)
+    except (ValueError, RPCError):
+        return None
 
-    await bot_client.send_message(
-        OWNER_ID, f"✅ تم سحب {count} إعلان (فيه سعر وصورة) من قناة {channel_username}"
+
+# ─────────────────────────────────────────────────────────────────────────
+# /start
+# ─────────────────────────────────────────────────────────────────────────
+@client.on(events.NewMessage(pattern=r"^/start$"))
+async def start_handler(event):
+    user_id = event.sender_id
+    sender = await event.get_sender()
+    await upsert_user(user_id, getattr(sender, "username", None), getattr(sender, "first_name", None))
+    clear_state(user_id)
+    text = (
+        "🖤 **MF BLACKLIST** 🖤\n\n"
+        "بوت مركزي لإدارة بلاغات السرقة والانتحال داخل تيليجرام.\n"
+        "اختر أحد الخيارات:"
     )
+    await event.respond(text, buttons=await main_menu_buttons(user_id))
 
 
-def pick_account_for_new_channel() -> str | None:
-    """يوزع القنوات على حسابات المراقبة بالتناوب (round-robin). يرجع رقم الهاتف المختار."""
-    phones = list(active_accounts.keys())
-    if not phones:
-        return None
-    counter_doc = config_col.find_one_and_update(
-        {"_id": "rr_counter"},
-        {"$inc": {"value": 1}},
-        upsert=True,
-        return_document=ReturnDocument.AFTER,
+@client.on(events.NewMessage(pattern=r"^/search(?:\s+(.+))?$"))
+async def search_command(event):
+    user_id = event.sender_id
+    settings = await get_settings()
+    if not settings.get("search_enabled", True):
+        await event.respond("🔧 البحث متوقف حالياً من قبل الإدارة.")
+        return
+    query = event.pattern_match.group(1)
+    if not query:
+        set_state(user_id, "search", "await_query")
+        await event.respond(
+            "أرسل Username أو User ID للبحث عنه.\nمثال: `@username` أو `123456789`",
+            buttons=[back_cancel_row()],
+        )
+        return
+    await perform_search(event, query.strip())
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Callback query router
+# ─────────────────────────────────────────────────────────────────────────
+@client.on(events.CallbackQuery())
+async def callback_router(event):
+    user_id = event.sender_id
+    data = event.data.decode("utf-8", errors="ignore")
+    try:
+        if not check_flood(user_id):
+            await event.answer("⏳ الرجاء الان��ظار قليلاً قبل المتابعة.", alert=True)
+            return
+
+        parts = data.split(":")
+        root = parts[0]
+
+        if root == "menu" and parts[1] == "main":
+            clear_state(user_id)
+            await event.edit("🖤 **MF BLACKLIST** 🖤\n\nاختر أحد الخيارات:",
+                              buttons=await main_menu_buttons(user_id))
+
+        elif root == "flow" and parts[1] == "cancel":
+            clear_state(user_id)
+            await event.edit("❌ تم إلغاء العملية.", buttons=await main_menu_buttons(user_id))
+
+        elif root == "help":
+            await show_help(event)
+
+        elif root == "channel" and parts[1] == "show":
+            await show_channel(event)
+
+        elif root == "report":
+            await handle_report_callback(event, parts)
+
+        elif root == "evidence":
+            await handle_evidence_callback(event, parts)
+
+        elif root == "confirm":
+            await handle_confirm_callback(event, parts)
+
+        elif root == "search":
+            await handle_search_callback(event, parts)
+
+        elif root == "case":
+            await handle_case_callback(event, parts)
+
+        elif root == "admin":
+            await handle_admin_callback(event, parts)
+
+        elif root == "review":
+            await handle_review_callback(event, parts)
+
+        elif root == "template":
+            await handle_template_callback(event, parts)
+
+        elif root == "settings":
+            await handle_settings_callback(event, parts)
+
+        elif root == "cases":
+            await handle_cases_callback(event, parts)
+
+        else:
+            await event.answer("❓ زر غير معروف.")
+    except events.StopPropagation:
+        raise
+    except Exception as e:
+        log.exception("Error handling callback %s: %s", data, e)
+        try:
+            await event.answer("⚠️ حدث خطأ غير متوقع. حاول مرة أخرى.", alert=True)
+        except Exception:
+            pass
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Help / channel info
+# ─────────────────────────────────────────────────────────────────────────
+async def show_help(event):
+    text = (
+        "📖 **شرح البوت**\n\n"
+        "MF BLACKLIST بوت للإبلاغ عن السرقة والانتحال في تيليجرام.\n\n"
+        "🚨 نشر سارق / ⚠️ نشر منتحل: لتقديم بلاغ جديد مع أدلة.\n"
+        "🔍 البحث عن شخص: للتحقق من وجود بلاغات سابقة ضد شخص.\n\n"
+        "كل بلاغ يُراجع من الإدارة قبل نشره في القناة الرسمية."
     )
-    idx = counter_doc["value"] % len(phones)
-    return phones[idx]
-
-
-async def connect_account_from_session(phone: str, session_string: str) -> TelegramClient:
-    """يعيد اتصال حساب مراقبة محفوظ مسبقًا (جلسته مخزنة بـ Mongo)."""
-    client = TelegramClient(StringSession(session_string), API_ID, API_HASH)
-    await client.connect()
-    active_accounts[phone] = client
-    task = asyncio.create_task(client.run_until_disconnected())
-    background_tasks.append(task)
-    return client
-
-
-# ---------------------------------------------------------------------------
-# البوت التفاعلي (bot_client) - مقفول على OWNER_ID فقط
-# ---------------------------------------------------------------------------
-# حالة المحادثة الحالية لكل مستخدم (هنا بس المالك أصلاً)
-pending_action: dict[int, str] = {}
-# بيانات تسجيل دخول حساب مراقبة قيد الإضافة حاليًا
-pending_login: dict[int, dict] = {}
-
-MAIN_MENU = [
-    [Button.inline("📖 الشرح", b"help")],
-    [Button.inline("👤 إضافة حساب مراقبة", b"add_account")],
-    [Button.inline("➕ إضافة قناة مراقبة", b"add_channel")],
-    [Button.inline("📅 تعيين تاريخ المراقبة", b"set_date")],
-    [Button.inline("🎯 تقييم حساب", b"evaluate")],
-]
+    await event.edit(text, buttons=[[Button.inline("🔙 رجوع", b"menu:main")]])
 
-HELP_TEXT = (
-    "هذا بوت تسعير حسابات Bounty Rush.\n\n"
-    "👤 إضافة حساب مراقبة: تضيف حساب تيليجرام (رقم هاتف) يستخدمه البوت "
-    "للانضمام للقنوات ومراقبتها. تقدر تضيف أكثر من حساب، وكل قناة تنضاف "
-    "توزع تلقائيًا على أحد الحسابات.\n\n"
-    "➕ إضافة قناة مراقبة: أعطيني يوزر قناة (بدون @)، وراح يتكفل فيها "
-    "أحد حسابات المراقبة المضافة وينضم لها ويراقب منشوراتها.\n\n"
-    "📅 تعيين تاريخ المراقبة: أعطيني تاريخ بصيغة YYYY|MM|DD مثل 2026|1|1، "
-    "وراح أسحب كل منشور فيه صورة حساب وسعر من كل القنوات المضافة، من هذا "
-    "التاريخ إلى اليوم.\n\n"
-    "🎯 تقييم حساب: أرسل صورة سكرين شوت من داخل الحساب، وراح أطلعلك سعر "
-    "تقريبي بناءً على أقرب الحسابات المشابهة المخزنة عندي."
-)
 
+async def show_channel(event):
+    settings = await get_settings()
+    uname = settings.get("channel_username")
+    if uname:
+        text = f"📢 قناة النشر الرسمية:\nhttps://t.me/{uname}"
+    else:
+        text = "📢 لم يتم تحديد قناة النشر بعد من قبل الإدارة."
+    await event.edit(text, buttons=[[Button.inline("🔙 رجوع", b"menu:main")]])
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Report flow (thief / impersonator share logic via report_type)
+# ─────────────────────────────────────────────────────────────────────────
+async def handle_report_callback(event, parts):
+    user_id = event.sender_id
+    settings = await get_settings()
+    if not settings.get("reports_enabled", True):
+        await event.answer("🔧 استقبال البلاغات متوقف حالياً.", alert=True)
+        return
 
-def _is_owner(user_id: int) -> bool:
-    return user_id == OWNER_ID
+    report_type = parts[1]  # thief | impersonator
+    action = parts[2] if len(parts) > 2 else None
 
+    if action == "start":
+        remaining = check_cooldown(user_id)
+        if remaining > 0:
+            await event.answer(f"⏳ الرجاء الانتظار {int(remaining)} ثانية قبل تقديم بلاغ جديد.", alert=True)
+            return
+        set_state(user_id, f"report_{report_type}", "await_username", {"type": report_type, "evidence": []})
+        label = TYPE_LABEL[report_type]
+        await event.edit(
+            f"🚨 بلاغ {label} — الخطوة 1\n\nأرسل Username الشخص مثل @username",
+            buttons=[
+                [Button.inline("لا يوجد معرف", f"report:{report_type}:no_id".encode())],
+                back_cancel_row(),
+            ],
+        )
 
-@bot_client.on(events.NewMessage(pattern="/start"))
-async def start_command(event):
-    if not _is_owner(event.sender_id):
+    elif action == "no_id":
+        st = get_state(user_id)
+        if not st or not st["flow"].startswith("report_"):
+            await event.answer("انتهت الجلسة، ابدأ من جديد.", alert=True)
+            return
+        st["step"] = "await_userid"
+        touch_state(user_id)
+        await event.edit(
+            "أرسل Telegram User ID (أرقام فقط).",
+            buttons=[back_cancel_row()],
+        )
+
+
+async def handle_evidence_callback(event, parts):
+    user_id = event.sender_id
+    action = parts[1]
+    st = get_state(user_id)
+    if not st or not st["flow"].startswith("report_"):
+        await event.answer("انتهت الجلسة، ابدأ من جديد.", alert=True)
         return
-    await event.respond("أهلاً بيك 👋 اختر شنو تبي تسوي:", buttons=MAIN_MENU)
+    if action == "done":
+        evidence = st["data"].get("evidence", [])
+        if not evidence:
+            await event.answer("يجب إرسال دليل واحد على الأقل.", alert=True)
+            return
+        st["step"] = "await_description"
+        touch_state(user_id)
+        await event.edit(
+            f"✅ تم استلام {len(evidence)} دليل/أدلة.\n\nاكتب موضوع السرقة/الانتحال بالتفصيل.",
+            buttons=[back_cancel_row()],
+        )
 
 
-@bot_client.on(events.CallbackQuery)
-async def button_callback(event):
-    if not _is_owner(event.sender_id):
+async def handle_confirm_callback(event, parts):
+    user_id = event.sender_id
+    action = parts[1]
+    st = get_state(user_id)
+    if not st or not st["flow"].startswith("report_"):
+        await event.answer("انتهت الجلسة، ابدأ من جديد.", alert=True)
         return
-    data = event.data.decode()
-    uid = event.sender_id
 
-    if data == "help":
-        await event.answer()
-        await event.respond(HELP_TEXT)
+    if action == "cancel":
+        clear_state(user_id)
+        await event.edit("❌ تم إلغاء البلاغ.", buttons=await main_menu_buttons(user_id))
+        return
 
-    elif data == "add_account":
-        pending_action[uid] = "await_add_account_phone"
-        await event.answer()
-        await event.respond(
-            "أرسل رقم هاتف حساب المراقبة بصيغة دولية كاملة، مثال:\n+9647701234567"
-        )
+    if action == "edit":
+        st["step"] = "await_description"
+        touch_state(user_id)
+        await event.edit("✏️ أرسل موضوع السرقة/الانتحال من جديد.", buttons=[back_cancel_row()])
+        return
 
-    elif data == "add_channel":
-        if not active_accounts:
-            await event.answer()
-            await event.respond(
-                "ما عندك أي حساب مراقبة مضاف بعد. اضغط '👤 إضافة حساب مراقبة' أول."
-            )
+    if action == "send":
+        data = st["data"]
+        report_type = data["type"]
+        case_id = await next_case_id()
+        now = datetime.datetime.utcnow()
+        case_doc = {
+            "case_id": case_id,
+            "type": report_type,
+            "user_id": data.get("target_user_id"),
+            "username": data.get("target_username"),
+            "submitter_id": user_id,
+            "description": data.get("description", ""),
+            "evidence": data.get("evidence", []),
+            "status": "pending",
+            "created_at": now,
+            "reviewed_at": None,
+            "reviewer_id": None,
+            "channel_id": None,
+            "channel_message_id": None,
+            "published_at": None,
+        }
+        try:
+            await col_cases.insert_one(case_doc)
+            await col_pending.insert_one({"case_id": case_id, "created_at": now})
+        except PyMongoError as e:
+            log.error("Failed to insert case: %s", e)
+            await event.edit("⚠️ حدث خطأ أثناء حفظ البلاغ. حاول مرة أخرى لاحقاً.",
+                              buttons=await main_menu_buttons(user_id))
+            clear_state(user_id)
             return
-        pending_action[uid] = "await_channel"
-        await event.answer()
-        await event.respond("ارسللي يوزر القناة اللي تبيني أراقبها (بدون @)، مثال:\nbountyrush_market")
 
-    elif data == "set_date":
-        pending_action[uid] = "await_date"
-        await event.answer()
-        await event.respond("ارسل تاريخ بداية المراقبة بهذي الصيغة بالضبط:\nYYYY|MM|DD\nمثال: 2026|1|1")
+        mark_action(user_id)
+        clear_state(user_id)
+        await log_action(user_id, "create_case", {"type": report_type}, case_id=case_id)
+        await send_to_review_group(case_doc)
+        await event.edit(
+            f"✅ تم إرسال بلاغك بنجاح.\nرقم البلاغ: {case_id}\nسيتم مراجعته من قبل الإدارة.",
+            buttons=await main_menu_buttons(user_id),
+        )
 
-    elif data == "evaluate":
-        pending_action[uid] = "await_photo"
-        await event.answer()
-        await event.respond("ارسللي صورة سكرين شوت من الحساب وراح أقيمه 📸")
 
+# ─────────────────────────────────────────────────────────────────────────
+# Message handler (drives multi-step flows: text + media)
+# ─────────────────────────────────────────────────────────────────────────
+@client.on(events.NewMessage(func=lambda e: e.is_private and not (e.raw_text or "").startswith("/")))
+async def message_router(event):
+    user_id = event.sender_id
+    st = get_state(user_id)
+    if not st:
+        return  # ignore unexpected messages outside of a flow
 
-@bot_client.on(events.NewMessage(func=lambda e: e.sender_id == OWNER_ID and e.photo))
-async def photo_message_handler(event):
-    await event.respond("جاري تحليل الصورة، لحظات... ⏳")
+    if not check_flood(user_id):
+        await event.respond("⏳ الرجاء الانتظار قليلاً.")
+        return
 
-    image_bytes = await event.download_media(file=bytes)
-    image = Image.open(io.BytesIO(image_bytes))
+    flow = st["flow"]
+    try:
+        if flow.startswith("report_"):
+            await drive_report_flow(event, st)
+        elif flow == "search":
+            await drive_search_flow(event, st)
+        elif flow == "admin_add":
+            await drive_admin_add_flow(event, st)
+        elif flow == "template_edit":
+            await drive_template_edit_flow(event, st)
+        elif flow == "channel_set":
+            await drive_channel_set_flow(event, st)
+        elif flow == "review_group_set":
+            await drive_review_group_set_flow(event, st)
+        elif flow == "maintenance_msg":
+            await drive_maintenance_msg_flow(event, st)
+        elif flow == "case_search":
+            await drive_case_search_flow(event, st)
+        elif flow == "provide_more_info":
+            await drive_more_info_flow(event, st)
+        else:
+            clear_state(user_id)
+    except events.StopPropagation:
+        raise
+    except Exception as e:
+        log.exception("Error in message_router (flow=%s): %s", flow, e)
+        await event.respond("⚠️ حدث خطأ غير متوقع، تم إلغاء العملية الحالية.")
+        clear_state(user_id)
+
+
+async def drive_report_flow(event, st):
+    user_id = event.sender_id
+    step = st["step"]
+    data = st["data"]
+    report_type = data["type"]
+
+    if step == "await_username":
+        text = (event.raw_text or "").strip()
+        if not text.startswith("@") and not text.replace("_", "").isalnum():
+            await event.respond("الرجاء إرسال Username صحيح مثل @username، أو اضغط 'لا يوجد معرف'.")
+            return
+        entity = await resolve_username(text)
+        if entity:
+            data["target_username"] = getattr(entity, "username", text.lstrip("@"))
+            data["target_user_id"] = entity.id
+            await proceed_to_duplicate_check(event, st)
+        else:
+            data["target_username"] = text.lstrip("@")
+            data["target_user_id"] = None
+            st["step"] = "await_userid_fallback"
+            touch_state(user_id)
+            await event.respond(
+                "تعذر الحصول على معلومات هذا المستخدم تلقائياً.\n"
+                "أرسل Telegram User ID الخاص به إن كان معروفاً، أو اكتب 'تخطي' للمتابعة بدون ID."
+            )
 
-    specs = extract_specs_from_image(image)
-    embedding = get_image_embedding(image)
-    result = find_similar_and_price(embedding, specs)
-    pending_action.pop(event.sender_id, None)
+    elif step == "await_userid_fallback":
+        text = (event.raw_text or "").strip()
+        if text in ("تخطي", "skip"):
+            await proceed_to_duplicate_check(event, st)
+            return
+        if not text.isdigit():
+            await event.respond("الرجاء إرسال رقم ID صحيح، أو اكتب 'تخطي'.")
+            return
+        data["target_user_id"] = int(text)
+        await proceed_to_duplicate_check(event, st)
 
-    if not result["matches"]:
+    elif step == "await_userid":
+        text = (event.raw_text or "").strip()
+        if not text.isdigit():
+            await event.respond("الرجاء إرسال Telegram User ID كرقم صحيح.")
+            return
+        uid = int(text)
+        entity = await resolve_user_id(uid)
+        data["target_user_id"] = uid
+        data["target_username"] = getattr(entity, "username", None) if entity else None
+        await proceed_to_duplicate_check(event, st)
+
+    elif step == "await_evidence":
+        if event.photo or event.video or event.document or event.file:
+            data.setdefault("evidence", []).append({
+                "message_id": event.id,
+                "chat_id": event.chat_id,
+                "media_type": (
+                    "photo" if event.photo else
+                    "video" if event.video else
+                    "document"
+                ),
+            })
+            touch_state(user_id)
+            count = len(data["evidence"])
+            await event.respond(
+                f"✅ تم استلام الدليل رقم {count}. أرسل المزيد أو اضغط 'تم إرسال جميع الأدلة'.",
+                buttons=[[Button.inline("✅ تم إرسال جميع الأدلة", b"evidence:done")], back_cancel_row()],
+            )
+        else:
+            await event.respond(
+                "الرجاء إرسال صورة، فيديو أو ملف كدليل، أو اضغط 'تم إرسال جميع الأدلة'.",
+                buttons=[[Button.inline("✅ تم إرسال جميع الأدلة", b"evidence:done")], back_cancel_row()],
+            )
+
+    elif step == "await_description":
+        text = (event.raw_text or "").strip()
+        if not text:
+            await event.respond("الرجاء إرسال نص يصف الموضوع بالتفصيل.")
+            return
+        data["description"] = text
+        st["step"] = "confirm"
+        touch_state(user_id)
+        await send_preview(event, data)
+
+
+async def proceed_to_duplicate_check(event, st):
+    user_id = event.sender_id
+    data = st["data"]
+    dup = None
+    if data.get("target_user_id"):
+        dup = await col_cases.find_one({"user_id": data["target_user_id"]})
+    elif data.get("target_username"):
+        dup = await col_cases.find_one({"username": data["target_username"]})
+
+    if dup and not data.get("dup_ack"):
+        data["dup_ack_pending"] = True
+        st["step"] = "await_dup_ack"
+        touch_state(user_id)
         await event.respond(
-            "قاعدة البيانات لسا ما فيها حسابات كافية أقارن عليها. "
-            "خلي البوت يراقب القنوات فترة وبعدين جرب مرة ثانية."
+            f"⚠️ يوجد بلاغ مسجل مسبقاً لهذا المستخدم (رقم البلاغ: {dup.get('case_id')}).",
+            buttons=[
+                [Button.inline("متابعة وإرسال بلاغ جديد", b"dup:continue")],
+                back_cancel_row(),
+            ],
         )
         return
+    await proceed_to_evidence(event, st)
 
-    lines = [f"💰 السعر التقريبي: {result['estimated_price']}"]
-    if specs.get("level"):
-        lines.append(f"📊 الليفل المقروء من صورتك: {specs['level']}")
-    if specs.get("gems"):
-        lines.append(f"💎 الجواهر المقروءة من صورتك: {specs['gems']}")
-    lines.append("\nأقرب حسابات مشابهة لقيتها:")
-    for m in result["matches"]:
-        lines.append(
-            f"- تشابه {m['similarity_percent']}% | سعر {m['price']} "
-            f"| ليفل {m.get('level', '؟')} | جواهر {m.get('gems', '؟')}"
-        )
 
-    await event.respond("\n".join(lines))
+@client.on(events.CallbackQuery(pattern=b"^dup:continue$"))
+async def dup_continue_handler(event):
+    user_id = event.sender_id
+    st = get_state(user_id)
+    if not st or not st["flow"].startswith("report_"):
+        await event.answer("انتهت الجلسة.", alert=True)
+        return
+    st["data"]["dup_ack"] = True
+    await proceed_to_evidence(event, st, is_callback=True)
+
+
+async def proceed_to_evidence(event, st, is_callback=False):
+    user_id = event.sender_id if not is_callback else event.sender_id
+    st["step"] = "await_evidence"
+    st["data"].setdefault("evidence", [])
+    touch_state(user_id)
+    msg = "أرسل صور وفيديوهات وملفات وأدلة السرقة.\nيمكنك إرسال عدة أدلة."
+    buttons = [[Button.inline("✅ تم إرسال جميع الأدلة", b"evidence:done")], back_cancel_row()]
+    if is_callback:
+        await event.edit(msg, buttons=buttons)
+    else:
+        await event.respond(msg, buttons=buttons)
+
+
+async def send_preview(event, data):
+    label = TYPE_LABEL[data["type"]]
+    uname = f"@{data['target_username']}" if data.get("target_username") else "غير متوفر"
+    uid = data.get("target_user_id") or "غير متوفر"
+    evidence_count = len(data.get("evidence", []))
+    text = (
+        "━━━━━━━━━━━━\n"
+        f"نوع البلاغ: {label}\n"
+        f"Username: {uname}\n"
+        f"User ID: {uid}\n"
+        f"عدد الأدلة: {evidence_count}\n\n"
+        f"الموضوع:\n{data.get('description','')}\n"
+        "━━━━━━━━━━━━"
+    )
+    await event.respond(
+        text,
+        buttons=[
+            [Button.inline("✅ إرسال البلاغ", b"confirm:send")],
+            [Button.inline("✏️ تعديل", b"confirm:edit")],
+            [Button.inline("❌ إلغاء", b"confirm:cancel")],
+        ],
+    )
 
 
-async def _finalize_new_account(uid: int, client: TelegramClient, phone: str):
-    session_string = client.session.save()
-    me = await client.get_me()
-    accounts_col.update_one(
-        {"phone": phone},
-        {"$set": {"phone": phone, "session": session_string, "user_id": me.id, "first_name": me.first_name}},
-        upsert=True,
-    )
-    active_accounts[phone] = client
-    task = asyncio.create_task(client.run_until_disconnected())
-    background_tasks.append(task)
+# ─────────────────────────────────────────────────────────────────────────
+# Sending report to review group / publishing to channel
+# ─────────────────────────────────────────────────────────────────────────
+async def send_to_review_group(case_doc):
+    settings = await get_settings()
+    group_id = settings.get("review_group_id")
+    if not group_id:
+        log.warning("No review group configured; case %s not forwarded", case_doc["case_id"])
+        return
 
-    await bot_client.send_message(
-        uid, f"✅ تمت إضافة حساب المراقبة: {me.first_name} ({phone})"
+    label = TYPE_LABEL.get(case_doc["type"], case_doc["type"])
+    submitter = case_doc.get("submitter_id")
+    text = (
+        "🆕 بلاغ جديد\n\n"
+        f"Case ID: {case_doc['case_id']}\n"
+        f"النوع: {label}\n"
+        f"Username: @{case_doc['username']}\n" if case_doc.get("username") else "Username: غير متوفر\n"
+    )
+    text += (
+        f"User ID: {case_doc.get('user_id') or 'غير متوفر'}\n"
+        f"مقدم البلاغ: {submitter}\n\n"
+        f"الموضوع:\n{case_doc.get('description','')}\n\n"
+        f"عدد الأدلة: {len(case_doc.get('evidence', []))}"
     )
-    pending_login.pop(uid, None)
-    pending_action.pop(uid, None)
+    buttons = [
+        [Button.inline("✅ موافقة ونشر", f"review:approve:{case_doc['case_id']}".encode())],
+        [Button.inline("❌ رفض", f"review:reject:{case_doc['case_id']}".encode())],
+        [Button.inline("📝 طلب معلومات", f"review:info:{case_doc['case_id']}".encode())],
+    ]
+    try:
+        await safe_call(client.send_message, group_id, text, buttons=buttons)
+        for ev in case_doc.get("evidence", []):
+            try:
+                await safe_call(client.forward_messages, group_id, ev["message_id"], ev["chat_id"])
+            except RPCError as e:
+                log.error("Failed forwarding evidence for %s: %s", case_doc["case_id"], e)
+    except RPCError as e:
+        log.error("Failed to send case %s to review group: %s", case_doc["case_id"], e)
+
+
+async def publish_case(case_doc, admin_id):
+    settings = await get_settings()
+    channel_id = settings.get("channel_id")
+    if not channel_id:
+        return False, "لم يتم تحديد قناة النشر بعد."
+
+    template = settings.get("template_thief") if case_doc["type"] == "thief" else settings.get("template_impersonator")
+    template = template or (DEFAULT_TEMPLATE_THIEF if case_doc["type"] == "thief" else DEFAULT_TEMPLATE_IMPERSONATOR)
 
+    rendered = render_template(template, case_doc)
 
-@bot_client.on(
-    events.NewMessage(
-        func=lambda e: e.sender_id == OWNER_ID and e.text and not e.text.startswith("/") and not e.photo
+    try:
+        evidence = case_doc.get("evidence", [])
+        sent_msg = None
+        if evidence:
+            first = evidence[0]
+            sent_msg = await safe_call(
+                client.send_message, channel_id, rendered,
+                file=await get_input_media(first),
+            )
+            for ev in evidence[1:]:
+                try:
+                    await safe_call(client.forward_messages, channel_id, ev["message_id"], ev["chat_id"])
+                except RPCError as e:
+                    log.error("Failed forwarding extra evidence to channel: %s", e)
+        else:
+            sent_msg = await safe_call(client.send_message, channel_id, rendered)
+
+        now = datetime.datetime.utcnow()
+        await col_cases.update_one(
+            {"case_id": case_doc["case_id"]},
+            {"$set": {
+                "status": "approved",
+                "reviewed_at": now,
+                "reviewer_id": admin_id,
+                "channel_id": channel_id,
+                "channel_message_id": sent_msg.id,
+                "published_at": now,
+            }},
+        )
+        await col_pending.delete_one({"case_id": case_doc["case_id"]})
+        return True, None
+    except RPCError as e:
+        log.error("Publishing failed for case %s: %s", case_doc["case_id"], e)
+        return False, str(e)
+
+
+async def get_input_media(evidence_item):
+    try:
+        msg = await client.get_messages(evidence_item["chat_id"], ids=evidence_item["message_id"])
+        if msg and msg.media:
+            return msg.media
+    except RPCError:
+        pass
+    return None
+
+
+def render_template(template: str, case_doc: dict) -> str:
+    return template.format(
+        case_id=case_doc.get("case_id", ""),
+        username=("@" + case_doc["username"]) if case_doc.get("username") else "غير متوفر",
+        user_id=case_doc.get("user_id") or "غير متوفر",
+        date=case_doc.get("created_at", datetime.datetime.utcnow()).strftime("%Y-%m-%d"),
+        description=case_doc.get("description", ""),
+        type=TYPE_LABEL.get(case_doc.get("type"), case_doc.get("type")),
     )
-)
-async def text_message_handler(event):
-    uid = event.sender_id
-    action = pending_action.get(uid)
-    text = event.text.strip()
-
-    # ---------------- إضافة حساب مراقبة: خطوة رقم الهاتف ----------------
-    if action == "await_add_account_phone":
-        phone = text.strip()
-        if not re.match(r"^\+\d{8,15}$", phone):
-            await event.respond("صيغة الرقم غلط. لازم يبدأ بـ + ورمز الدولة، مثال: +9647701234567")
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Review callbacks (approve / reject / request info)
+# ─────────────────────────────────────────────────────────────────────────
+async def handle_review_callback(event, parts):
+    user_id = event.sender_id
+    action = parts[1]
+    case_id = parts[2]
+
+    case_doc = await col_cases.find_one({"case_id": case_id})
+    if not case_doc:
+        await event.answer("⚠️ لم يتم العثور على البلاغ.", alert=True)
+        return
+
+    if action == "approve":
+        if not await has_permission(user_id, "approve_reports"):
+            await event.answer("🚫 ليس لديك صلاحية الموافقة على البلاغات.", alert=True)
             return
-        temp_client = TelegramClient(StringSession(), API_ID, API_HASH)
-        try:
-            await temp_client.connect()
-            result = await temp_client.send_code_request(phone)
-        except FloodWaitError as e:
-            await event.respond(f"محاولات كثيرة، لازم تنتظر {e.seconds} ثانية وتحاول مرة ثانية.")
-            await temp_client.disconnect()
+        ok, err = await publish_case(case_doc, user_id)
+        if ok:
+            await log_action(user_id, "approve", case_id=case_id)
+            await event.answer("✅ تم النشر بنجاح.")
+            try:
+                await event.edit(event.text + "\n\n✅ تمت الموافقة والنشر.", buttons=None)
+            except Exception:
+                pass
+            try:
+                await safe_call(client.send_message, case_doc["submitter_id"],
+                                 "تمت مراجعة البلاغ والموافقة عليه ونشره.")
+            except RPCError:
+                pass
+        else:
+            await event.answer(f"⚠️ فشل النشر: {err}", alert=True)
+            try:
+                await safe_call(client.send_message, user_id, f"⚠️ فشل نشر البلاغ {case_id}: {err}")
+            except RPCError:
+                pass
+
+    elif action == "reject":
+        if not await has_permission(user_id, "reject_reports"):
+            await event.answer("🚫 ليس لديك صلاحية رفض البلاغات.", alert=True)
             return
+        await col_cases.update_one(
+            {"case_id": case_id},
+            {"$set": {"status": "rejected", "reviewed_at": datetime.datetime.utcnow(), "reviewer_id": user_id}},
+        )
+        await col_pending.delete_one({"case_id": case_id})
+        await log_action(user_id, "reject", case_id=case_id)
+        await event.answer("❌ تم رفض البلاغ.")
+        try:
+            await event.edit(event.text + "\n\n❌ تم الرفض.", buttons=None)
         except Exception:
-            log.exception("فشل إرسال كود التحقق")
-            await event.respond("صار خطأ بإرسال كود التحقق. تأكد من الرقم وحاول مرة ثانية.")
-            await temp_client.disconnect()
-            return
-
-        pending_login[uid] = {
-            "client": temp_client,
-            "phone": phone,
-            "phone_code_hash": result.phone_code_hash,
-        }
-        pending_action[uid] = "await_add_account_code"
-        await event.respond("وصلك كود التحقق بتطبيق تيليجرام. ارسله هنا:")
-
-    # ---------------- إضافة حساب مراقبة: خطوة كود التحقق ----------------
-    elif action == "await_add_account_code":
-        login = pending_login.get(uid)
-        if not login:
-            pending_action.pop(uid, None)
-            await event.respond("صار خطأ، ابدأ من جديد بزر '👤 إضافة حساب مراقبة'.")
+            pass
+        try:
+            await safe_call(client.send_message, case_doc["submitter_id"],
+                             f"تم رفض البلاغ {case_id} من قبل الإدارة.")
+        except RPCError:
+            pass
+
+    elif action == "info":
+        if not await has_permission(user_id, "manage_reports"):
+            await event.answer("🚫 ليس لديك صلاحية طلب معلومات.", alert=True)
             return
-        code = text.strip()
-        client = login["client"]
+        await col_cases.update_one(
+            {"case_id": case_id},
+            {"$set": {"status": "needs_more_info"}},
+        )
+        await log_action(user_id, "request_info", case_id=case_id)
+        set_state(case_doc["submitter_id"], "provide_more_info", "await_text", {"case_id": case_id})
         try:
-            await client.sign_in(phone=login["phone"], code=code, phone_code_hash=login["phone_code_hash"])
-        except SessionPasswordNeededError:
-            pending_action[uid] = "await_add_account_password"
-            await event.respond("حسابك مفعل عليه تحقق بخطوتين. أرسل كلمة السر:")
+            await safe_call(client.send_message, case_doc["submitter_id"],
+                             f"الإدارة تحتاج معلومات إضافية عن البلاغ {case_id}.\n"
+                             "الرجاء إرسال المعلومات الإضافية الآن.")
+        except RPCError:
+            pass
+        await event.answer("📝 تم إرسال طلب المعلومات للمُبلِّغ.")
+
+
+async def drive_more_info_flow(event, st):
+    user_id = event.sender_id
+    case_id = st["data"]["case_id"]
+    extra_text = (event.raw_text or "").strip()
+    if not extra_text:
+        await event.respond("الرجاء إرسال نص يحتوي المعلومات الإضافية.")
+        return
+    case_doc = await col_cases.find_one({"case_id": case_id})
+    if not case_doc:
+        clear_state(user_id)
+        return
+    new_desc = case_doc.get("description", "") + f"\n\n[معلومات إضافية]: {extra_text}"
+    await col_cases.update_one({"case_id": case_id}, {"$set": {"description": new_desc, "status": "pending"}})
+    await col_pending.update_one({"case_id": case_id}, {"$set": {"created_at": datetime.datetime.utcnow()}}, upsert=True)
+    clear_state(user_id)
+    case_doc["description"] = new_desc
+    await send_to_review_group(case_doc)
+    await event.respond("✅ تم إرسال المعلومات الإضافية، سيُعاد فحص البلاغ من قبل الإدارة.")
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Search
+# ─────────────────────────────────────────────────────────────────────────
+async def handle_search_callback(event, parts):
+    user_id = event.sender_id
+    action = parts[1]
+    if action == "start":
+        settings = await get_settings()
+        if not settings.get("search_enabled", True):
+            await event.answer("🔧 البحث متوقف حالياً.", alert=True)
             return
-        except (PhoneCodeInvalidError, PhoneCodeExpiredError):
-            await event.respond("الكود غلط أو منتهي. ابدأ من جديد بزر '👤 إضافة حساب مراقبة'.")
-            await client.disconnect()
-            pending_login.pop(uid, None)
-            pending_action.pop(uid, None)
+        set_state(user_id, "search", "await_query")
+        await event.edit(
+            "أرسل Username أو User ID للبحث عنه.\nمثال: @username أو 123456789",
+            buttons=[back_cancel_row()],
+        )
+
+
+async def drive_search_flow(event, st):
+    query = (event.raw_text or "").strip()
+    if not query:
+        await event.respond("الرجاء إرسال Username أو User ID صحيح.")
+        return
+    clear_state(event.sender_id)
+    await perform_search(event, query)
+
+
+async def perform_search(event, query):
+    query = query.strip()
+    target_user_id = None
+    target_username = None
+
+    if query.isdigit():
+        target_user_id = int(query)
+    else:
+        target_username = query.lstrip("@")
+        entity = await resolve_username(target_username)
+        if entity:
+            target_user_id = entity.id
+            target_username = getattr(entity, "username", target_username)
+        # if not resolvable, we still try searching stored username as-is
+
+    mongo_filter = {"$or": []}
+    if target_user_id:
+        mongo_filter["$or"].append({"user_id": target_user_id})
+    if target_username:
+        mongo_filter["$or"].append({"username": target_username})
+
+    if not mongo_filter["$or"]:
+        await event.respond("تعذر الحصول على معلومات هذا الـUsername حالياً، حاول استخدام User ID.")
+        return
+
+    cases = await col_cases.find(mongo_filter).sort("created_at", ASCENDING).to_list(length=200)
+    if not cases:
+        await event.respond("لا توجد بلاغات مسجلة لهذا الشخص.")
+        return
+
+    total = len(cases)
+    thief_count = sum(1 for c in cases if c["type"] == "thief")
+    imp_count = sum(1 for c in cases if c["type"] == "impersonator")
+    first_date = cases[0]["created_at"].strftime("%Y-%m-%d")
+    last_date = cases[-1]["created_at"].strftime("%Y-%m-%d")
+    approved_count = sum(1 for c in cases if c["status"] == "approved")
+
+    uname_disp = f"@{cases[0]['username']}" if cases[0].get("username") else "غير متوفر"
+    uid_disp = cases[0].get("user_id") or "غير متوفر"
+
+    text = (
+        "🔍 نتائج البحث\n\n"
+        f"👤 Username: {uname_disp}\n"
+        f"🆔 User ID: {uid_disp}\n\n"
+        f"🚨 إجمالي البلاغات: {total}\n"
+        f"🔴 سارق: {thief_count}\n"
+        f"🟠 منتحل: {imp_count}\n"
+        f"✅ مقبولة: {approved_count}\n"
+        f"📅 أول بلاغ: {first_date}\n"
+        f"📅 آخر بلاغ: {last_date}"
+    )
+    buttons = []
+    for c in cases[:25]:
+        buttons.append([Button.inline(f"📄 {c['case_id']}", f"case:view:{c['case_id']}".encode())])
+    buttons.append([Button.inline("🔙 رجوع", b"menu:main")])
+    await event.respond(text, buttons=buttons)
+
+
+async def handle_case_callback(event, parts):
+    action = parts[1]
+    if action == "view":
+        case_id = parts[2]
+        case_doc = await col_cases.find_one({"case_id": case_id})
+        if not case_doc:
+            await event.answer("لم يتم العثور على البلاغ.", alert=True)
             return
-        except Exception:
-            log.exception("فشل تسجيل الدخو�� بالكود")
-            await event.respond("صار خطأ بتسجيل الدخول. ابدأ من جديد.")
-            await client.disconnect()
-            pending_login.pop(uid, None)
-            pending_action.pop(uid, None)
+        if case_doc.get("status") != "approved" or not case_doc.get("channel_message_id"):
+            await event.answer("هذا البلاغ غير منشور بعد.", alert=True)
             return
+        settings = await get_settings()
+        channel_username = settings.get("channel_username")
+        msg_id = case_doc["channel_message_id"]
+        if channel_username:
+            link = f"https://t.me/{channel_username}/{msg_id}"
+        else:
+            raw_channel_id = str(case_doc["channel_id"]).replace("-100", "")
+            link = f"https://t.me/c/{raw_channel_id}/{msg_id}"
+        await event.answer(url=link)
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Admin panel
+# ─────────────────────────────────────────────────────────────────────────
+async def handle_admin_callback(event, parts):
+    user_id = event.sender_id
+    if not await is_admin(user_id):
+        await event.answer("🚫 هذا القسم للإدارة فقط.", alert=True)
+        return
 
-        await _finalize_new_account(uid, client, login["phone"])
-
-    # ---------------- إضافة حساب مراقبة: خطوة كلمة السر (2FA) ----------------
-    elif action == "await_add_account_password":
-        login = pending_login.get(uid)
-        if not login:
-            pending_action.pop(uid, None)
-            await event.respond("صار خطأ، ابدأ من جديد بزر '👤 إضافة حساب مراقبة'.")
+    action = parts[1] if len(parts) > 1 else "panel"
+
+    if action == "panel":
+        await show_admin_panel(event)
+    elif action == "management":
+        await show_management_menu(event)
+    elif action == "add":
+        if not await has_permission(user_id, "manage_admins") or not is_owner(user_id):
+            if not is_owner(user_id):
+                await event.answer("🚫 إضافة الأدمن للـOwner فقط.", alert=True)
+                return
+        set_state(user_id, "admin_add", "await_id")
+        await event.edit("أرسل User ID للمستخدم الذي تريد إضافته كأدمن.", buttons=[back_cancel_row(b"admin:management")])
+    elif action == "list":
+        await show_admin_list(event)
+    elif action == "remove":
+        if not is_owner(user_id):
+            await event.answer("🚫 إزالة الأدمن للـOwner فقط.", alert=True)
             return
-        client = login["client"]
-        try:
-            await client.sign_in(password=text)
-        except PasswordHashInvalidError:
-            await event.respond("كلمة السر غلط. حاول ترسلها مرة ثانية:")
+        target_id = int(parts[2])
+        if target_id == OWNER_ID:
+            await event.answer("🚫 لا يمكن إزالة الـOwner.", alert=True)
             return
-        except Exception:
-            log.exception("فشل تسجيل الدخول بكلمة السر")
-            await event.respond("صار خطأ. ابدأ من جديد بزر '👤 إضافة حساب مراقبة'.")
-            await client.disconnect()
-            pending_login.pop(uid, None)
-            pending_action.pop(uid, None)
+        await col_admins.delete_one({"user_id": target_id})
+        await log_action(user_id, "remove_admin", {"target": target_id})
+        await event.answer("✅ تمت الإزالة.")
+        await show_admin_list(event)
+    elif action == "perms":
+        target_id = int(parts[2])
+        await show_admin_perms(event, target_id)
+    elif action == "permtoggle":
+        if not is_owner(user_id):
+            await event.answer("🚫 للـOwner فقط.", alert=True)
+            return
+        target_id = int(parts[2])
+        perm = parts[3]
+        doc = await col_admins.find_one({"user_id": target_id})
+        if not doc:
+            await event.answer("الأدمن غير موجود.", alert=True)
             return
+        current = doc.get("permissions", {}).get(perm, False)
+        await col_admins.update_one({"user_id": target_id}, {"$set": {f"permissions.{perm}": not current}})
+        await show_admin_perms(event, target_id)
+    elif action == "publishing":
+        await show_publishing_menu(event)
+    elif action == "setchannel":
+        set_state(user_id, "channel_set", "await_channel")
+        await event.edit("أرسل معرف/يوزر قناة النشر (مثال @channelname) أو ID الخاص بها.",
+                          buttons=[back_cancel_row(b"admin:publishing")])
+    elif action == "setreviewgroup":
+        set_state(user_id, "review_group_set", "await_group")
+        await event.edit("أرسل معرف/يوزر مجموعة المراجعة أو ID الخاصة بها.",
+                          buttons=[back_cancel_row(b"admin:publishing")])
+    elif action == "templates":
+        await show_templates_menu(event)
+    elif action == "stats":
+        await show_stats(event)
+    elif action == "reports_menu":
+        await show_reports_menu(event)
+    elif action == "settings_menu":
+        await show_settings_menu(event)
+
+
+async def show_admin_panel(event):
+    rows = [
+        [Button.inline("👑 الإدارة", b"admin:management")],
+        [Button.inline("📢 النشر", b"admin:publishing")],
+        [Button.inline("📊 الإحصائيات", b"admin:stats")],
+        [Button.inline("📋 إدارة البلاغات", b"admin:reports_menu")],
+        [Button.inline("⚙️ إعدادات", b"admin:settings_menu")],
+        [Button.inline("🔙 رجوع", b"menu:main")],
+    ]
+    await event.edit("🛠 **لوحة المطورين**", buttons=rows)
 
-        await _finalize_new_account(uid, client, login["phone"])
 
-    # ---------------- إضافة قناة مراقبة ----------------
-    elif action == "await_channel":
-        channel_username = text.lstrip("@").strip()
-        account_phone = pick_account_for_new_channel()
-        if not account_phone:
-            await event.respond("ما عندك أي حساب مراقبة مضاف. أضف حساب أول من زر '👤 إضافة حساب مراقبة'.")
-            pending_action.pop(uid, None)
-            return
+async def show_management_menu(event):
+    rows = [
+        [Button.inline("➕ إضافة أدمن", b"admin:add")],
+        [Button.inline("➖ إزالة أدمن", b"admin:list")],
+        [Button.inline("👥 قائمة الأدمنية", b"admin:list")],
+        [Button.inline("🔙 رجوع", b"admin:panel")],
+    ]
+    await event.edit("👑 **إدارة الأدمنية**", buttons=rows)
+
+
+async def show_admin_list(event):
+    admins = await col_admins.find().to_list(length=200)
+    rows = []
+    rows.append([Button.inline(f"👑 Owner ({OWNER_ID})", b"noop")])
+    for a in admins:
+        rows.append([
+            Button.inline(f"⚙️ {a['user_id']}", f"admin:perms:{a['user_id']}".encode()),
+            Button.inline("➖", f"admin:remove:{a['user_id']}".encode()),
+        ])
+    rows.append([Button.inline("🔙 رجوع", b"admin:management")])
+    await event.edit("👥 **قائمة الأدمنية**\n(اضغط ⚙️ لعرض/تعديل الصلاحيات)", buttons=rows)
+
+
+async def show_admin_perms(event, target_id):
+    doc = await col_admins.find_one({"user_id": target_id})
+    if not doc:
+        await event.answer("الأدمن غير موجود.", alert=True)
+        return
+    perms = doc.get("permissions", {})
+    rows = []
+    for p in ALL_PERMISSIONS:
+        state = "✅" if perms.get(p) else "❌"
+        rows.append([Button.inline(f"{state} {p}", f"admin:permtoggle:{target_id}:{p}".encode())])
+    rows.append([Button.inline("🔙 رجوع", b"admin:list")])
+    await event.edit(f"🔐 صلاحيات الأدمن {target_id}:", buttons=rows)
+
+
+async def drive_admin_add_flow(event, st):
+    user_id = event.sender_id
+    text = (event.raw_text or "").strip()
+    if not text.isdigit():
+        await event.respond("الرجاء إرسال User ID صحيح (أرقام فقط).")
+        return
+    target_id = int(text)
+    if target_id == OWNER_ID:
+        await event.respond("هذا المستخدم هو الـOwner بالفعل.")
+        clear_state(user_id)
+        return
+    existing = await col_admins.find_one({"user_id": target_id})
+    if existing:
+        await event.respond("هذا المستخدم أدمن بالفعل.")
+        clear_state(user_id)
+        return
+    await col_admins.insert_one({
+        "user_id": target_id,
+        "added_by": user_id,
+        "added_at": datetime.datetime.utcnow(),
+        "permissions": {p: False for p in ALL_PERMISSIONS},
+    })
+    await log_action(user_id, "add_admin", {"target": target_id})
+    clear_state(user_id)
+    await event.respond(f"✅ تمت إضافة {target_id} كأدمن. يمكنك الآن ضبط صلاحياته من قائمة الأدمنية.")
+
+
+async def show_publishing_menu(event):
+    settings = await get_settings()
+    ch = settings.get("channel_username") or settings.get("channel_id") or "غير محدد"
+    rg = settings.get("review_group_id") or "غير محدد"
+    rows = [
+        [Button.inline("📢 تحديد قناة النشر", b"admin:setchannel")],
+        [Button.inline("📥 تحديد مجموعة المراجعة", b"admin:setreviewgroup")],
+        [Button.inline("📝 كليشة السارق", b"template:edit:thief")],
+        [Button.inline("📝 كليشة المنتحل", b"template:edit:impersonator")],
+        [Button.inline("👁 معاينة الكليشات", b"template:preview:thief")],
+        [Button.inline("🔙 رجوع", b"admin:panel")],
+    ]
+    await event.edit(f"📢 **النشر**\nقناة النشر الحالية: {ch}\nمجموعة المراجعة الحالية: {rg}", buttons=rows)
 
-        channels_col.update_one(
-            {"channel": channel_username},
-            {"$set": {"channel": channel_username, "account_phone": account_phone}},
-            upsert=True,
-        )
-        assigned_client = active_accounts[account_phone]
-        await event.respond(f"⏳ جاري الانضمام لقناة {channel_username} (عبر حساب {account_phone})...")
-        await register_channel_monitor(assigned_client, channel_username)
-        await event.respond(f"✅ تمت إضافة {channel_username} للمراقبة اللحظية.")
-
-        cfg = config_col.find_one({"_id": "settings"})
-        if cfg and cfg.get("monitor_start_date"):
-            await event.respond("⏳ جاري سحب المنشورات القديمة لهذي القناة من التاريخ المحدد...")
-            asyncio.create_task(
-                backfill_channel(assigned_client, channel_username, cfg["monitor_start_date"])
-            )
-        pending_action.pop(uid, None)
 
-    # ---------------- تعيين تاريخ المراقبة ----------------
-    elif action == "await_date":
-        if not re.match(r"^\d{4}\|\d{1,2}\|\d{1,2}$", text):
-            await event.respond("صيغة غلط. لازم تكون هيك بالضبط: YYYY|MM|DD مثال: 2026|1|1")
-            return
-        year, month, day = (int(x) for x in text.split("|"))
-        try:
-            start_date = datetime(year, month, day, tzinfo=timezone.utc)
-        except ValueError:
-            await event.respond("التاريخ غير صالح، جرب مرة ثانية.")
-            return
+async def drive_channel_set_flow(event, st):
+    user_id = event.sender_id
+    if not await has_permission(user_id, "manage_settings") and not is_owner(user_id):
+        await event.respond("🚫 ليس لديك صلاحية.")
+        clear_state(user_id)
+        return
+    text = (event.raw_text or "").strip()
+    entity = None
+    try:
+        if text.lstrip("-").isdigit():
+            entity = await client.get_entity(int(text))
+        else:
+            entity = await client.get_entity(text.lstrip("@"))
+    except RPCError as e:
+        await event.respond(f"تعذر الوصول لهذه القناة: {e}")
+        clear_state(user_id)
+        return
+    if not isinstance(entity, Channel):
+        await event.respond("هذا ليس معرف قناة صالح.")
+        clear_state(user_id)
+        return
+    await update_settings({
+        "channel_id": entity.id if entity.id > 0 else int(f"-100{entity.id}"),
+        "channel_username": getattr(entity, "username", None),
+    })
+    clear_state(user_id)
+    await event.respond("✅ تم تحديد قناة النشر بنجاح.")
+
+
+async def drive_review_group_set_flow(event, st):
+    user_id = event.sender_id
+    if not await has_permission(user_id, "manage_settings") and not is_owner(user_id):
+        await event.respond("🚫 ليس لديك صلاحية.")
+        clear_state(user_id)
+        return
+    text = (event.raw_text or "").strip()
+    try:
+        if text.lstrip("-").isdigit():
+            entity = await client.get_entity(int(text))
+        else:
+            entity = await client.get_entity(text.lstrip("@"))
+    except RPCError as e:
+        await event.respond(f"تعذر الوصول لهذه المجموعة: {e}")
+        clear_state(user_id)
+        return
+    group_id = entity.id
+    if isinstance(entity, Channel):
+        group_id = int(f"-100{entity.id}")
+    elif isinstance(entity, Chat):
+        group_id = -entity.id
+    await update_settings({"review_group_id": group_id})
+    clear_state(user_id)
+    await event.respond("✅ تم تحديد مجموعة المراجعة بنجاح.")
+
+
+async def show_templates_menu(event):
+    rows = [
+        [Button.inline("📝 كليشة السارق", b"template:edit:thief")],
+        [Button.inline("📝 كليشة المنتحل", b"template:edit:impersonator")],
+        [Button.inline("👁 معاينة كليشة السارق", b"template:preview:thief")],
+        [Button.inline("👁 معاينة كليشة المنتحل", b"template:preview:impersonator")],
+        [Button.inline("🔙 رجوع", b"admin:publishing")],
+    ]
+    await event.edit("📝 **الكليشات**", buttons=rows)
 
-        config_col.update_one(
-            {"_id": "settings"}, {"$set": {"monitor_start_date": start_date}}, upsert=True
+
+async def handle_template_callback(event, parts):
+    user_id = event.sender_id
+    action = parts[1]
+    ttype = parts[2]
+    if action == "edit":
+        if not await has_permission(user_id, "edit_templates") and not is_owner(user_id):
+            await event.answer("🚫 ليس لديك صلاحية تعديل الكليشات.", alert=True)
+            return
+        set_state(user_id, "template_edit", "await_text", {"ttype": ttype})
+        await event.edit(
+            "أرسل نص الكليشة الجديد. المتغيرات المتاحة:\n"
+            "{case_id} {username} {user_id} {date} {description} {type}",
+            buttons=[back_cancel_row(b"admin:publishing")],
         )
-        pending_action.pop(uid, None)
+    elif action == "preview":
+        settings = await get_settings()
+        template = settings.get(f"template_{ttype}") or (
+            DEFAULT_TEMPLATE_THIEF if ttype == "thief" else DEFAULT_TEMPLATE_IMPERSONATOR
+        )
+        fake_case = {
+            "case_id": "MF-000000", "username": "example", "user_id": 123456789,
+            "created_at": datetime.datetime.utcnow(), "description": "مثال توضيحي للمعاينة.",
+            "type": ttype,
+        }
+        rendered = render_template(template, fake_case)
+        await event.edit(f"👁 معاينة:\n\n{rendered}", buttons=[[Button.inline("🔙 رجوع", b"admin:publishing")]])
 
-        all_channels = list(channels_col.find())
-        if not all_channels:
-            await event.respond(
-                "✅ تم حفظ التاريخ. بس ما عندك قنوات مضافة بعد - أضف قناة أول عشان أبدأ أسحب منها."
-            )
+
+async def drive_template_edit_flow(event, st):
+    user_id = event.sender_id
+    ttype = st["data"]["ttype"]
+    text = event.raw_text or ""
+    if not text.strip():
+        await event.respond("الرجاء إرسال نص صالح للكليشة.")
+        return
+    await update_settings({f"template_{ttype}": text})
+    clear_state(user_id)
+    await log_action(user_id, "edit_template", {"ttype": ttype})
+    await event.respond("✅ تم حفظ الكليشة بنجاح.")
+
+
+async def show_stats(event):
+    total = await col_cases.count_documents({})
+    thief = await col_cases.count_documents({"type": "thief"})
+    imp = await col_cases.count_documents({"type": "impersonator"})
+    pending = await col_cases.count_documents({"status": "pending"})
+    approved = await col_cases.count_documents({"status": "approved"})
+    rejected = await col_cases.count_documents({"status": "rejected"})
+    users_count = await col_users.count_documents({})
+    text = (
+        "📊 **الإحصائيات**\n\n"
+        f"إجمالي البلاغات: {total}\n"
+        f"بلاغات السرقة: {thief}\n"
+        f"بلاغات الانتحال: {imp}\n"
+        f"المعلقة: {pending}\n"
+        f"المقبولة: {approved}\n"
+        f"المرفوضة: {rejected}\n"
+        f"عدد المستخدمين: {users_count}"
+    )
+    await event.edit(text, buttons=[[Button.inline("🔙 رجوع", b"admin:panel")]])
+
+
+async def show_reports_menu(event):
+    rows = [
+        [Button.inline("البلاغات المعلقة", b"cases:list:pending")],
+        [Button.inline("البلاغات المقبولة", b"cases:list:approved")],
+        [Button.inline("البلاغات المرفوضة", b"cases:list:rejected")],
+        [Button.inline("البحث عن Case ID", b"cases:search")],
+        [Button.inline("🔙 رجوع", b"admin:panel")],
+    ]
+    await event.edit("📋 **إدارة البلاغات**", buttons=rows)
+
+
+async def handle_cases_callback(event, parts):
+    user_id = event.sender_id
+    if not await is_admin(user_id):
+        await event.answer("🚫 للإدارة فقط.", alert=True)
+        return
+    action = parts[1]
+    if action == "list":
+        status = parts[2]
+        cases = await col_cases.find({"status": status}).sort("created_at", DESCENDING).to_list(length=15)
+        if not cases:
+            await event.edit("لا توجد بلاغات في هذه الفئة.", buttons=[[Button.inline("🔙 رجوع", b"admin:reports_menu")]])
             return
+        lines = [f"{c['case_id']} — {TYPE_LABEL.get(c['type'], c['type'])} — {c.get('username') or c.get('user_id')}" for c in cases]
+        text = f"📋 آخر {len(cases)} بلاغ ({status}):\n\n" + "\n".join(lines)
+        await event.edit(text, buttons=[[Button.inline("🔙 رجوع", b"admin:reports_menu")]])
+    elif action == "search":
+        set_state(user_id, "case_search", "await_id")
+        await event.edit("أرسل رقم Case ID (مثال MF-000001).", buttons=[back_cancel_row(b"admin:reports_menu")])
+
+
+async def drive_case_search_flow(event, st):
+    user_id = event.sender_id
+    case_id = (event.raw_text or "").strip().upper()
+    case_doc = await col_cases.find_one({"case_id": case_id})
+    clear_state(user_id)
+    if not case_doc:
+        await event.respond("لم يتم العثور على بلاغ بهذا الرقم.")
+        return
+    text = (
+        f"Case ID: {case_doc['case_id']}\n"
+        f"النوع: {TYPE_LABEL.get(case_doc['type'], case_doc['type'])}\n"
+        f"Username: @{case_doc.get('username')}\n" if case_doc.get("username") else "Username: غير متوفر\n"
+    )
+    text += (
+        f"User ID: {case_doc.get('user_id') or 'غير متوفر'}\n"
+        f"ا��حالة: {case_doc['status']}\n"
+        f"مقدم البلاغ: {case_doc.get('submitter_id')}\n\n"
+        f"الموضوع:\n{case_doc.get('description','')}"
+    )
+    await event.respond(text)
+
+
+async def show_settings_menu(event):
+    settings = await get_settings()
+    reports_state = "✅ مفعّل" if settings.get("reports_enabled", True) else "❌ متوقف"
+    search_state = "✅ مفعّل" if settings.get("search_enabled", True) else "❌ متوقف"
+    rows = [
+        [Button.inline(f"تشغيل/إيقاف البلاغات ({reports_state})", b"settings:toggle_reports")],
+        [Button.inline(f"تشغيل/إيقاف البحث ({search_state})", b"settings:toggle_search")],
+        [Button.inline("رسالة الصيانة", b"settings:maintenance")],
+        [Button.inline("🔙 رجوع", b"admin:panel")],
+    ]
+    await event.edit("⚙️ **الإعدادات**", buttons=rows)
 
-        await event.respond(
-            f"✅ تم حفظ التاريخ. جاري سحب المنشورات من {len(all_channels)} قناة بدءًا من {text}..."
-        )
-        for ch in all_channels:
-            client = active_accounts.get(ch.get("account_phone"))
-            if client:
-                asyncio.create_task(backfill_channel(client, ch["channel"], start_date))
 
-    else:
-        await event.respond("اكتب /start لعرض القائمة.")
+async def handle_settings_callback(event, parts):
+    user_id = event.sender_id
+    if not await has_permission(user_id, "manage_settings"):
+        await event.answer("🚫 ليس لديك صلاحية تعديل الإعدادات.", alert=True)
+        return
+    action = parts[1]
+    settings = await get_settings()
+    if action == "toggle_reports":
+        await update_settings({"reports_enabled": not settings.get("reports_enabled", True)})
+        await log_action(user_id, "toggle_reports")
+        await show_settings_menu(event)
+    elif action == "toggle_search":
+        await update_settings({"search_enabled": not settings.get("search_enabled", True)})
+        await log_action(user_id, "toggle_search")
+        await show_settings_menu(event)
+    elif action == "maintenance":
+        set_state(user_id, "maintenance_msg", "await_text")
+        await event.edit("أرسل نص رسالة الصيانة الجديد.", buttons=[back_cancel_row(b"admin:settings_menu")])
+
+
+async def drive_maintenance_msg_flow(event, st):
+    user_id = event.sender_id
+    text = event.raw_text or ""
+    await update_settings({"maintenance_message": text})
+    clear_state(user_id)
+    await log_action(user_id, "set_maintenance_message")
+    await event.respond("✅ تم حفظ رسالة الصيانة.")
+
+
+@client.on(events.CallbackQuery(pattern=b"^noop$"))
+async def noop_handler(event):
+    await event.answer()
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# DB indexes
+# ─────────────────────────────────────────────────────────────────────────
+async def ensure_indexes():
+    await col_cases.create_index([("user_id", ASCENDING)])
+    await col_cases.create_index([("username", ASCENDING)])
+    await col_cases.create_index([("case_id", ASCENDING)], unique=True)
+    await col_cases.create_index([("status", ASCENDING)])
+    await col_cases.create_index([("type", ASCENDING)])
+    await col_cases.create_index([("channel_message_id", ASCENDING)])
+    await col_admins.create_index([("user_id", ASCENDING)], unique=True)
+    await col_users.create_index([("user_id", ASCENDING)], unique=True)
+    await col_logs.create_index([("timestamp", DESCENDING)])
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Startup checks
+# ─────────────────────────────────────────────────────────────────────────
+async def check_channel_permissions():
+    settings = await get_settings()
+    channel_id = settings.get("channel_id")
+    if not channel_id:
+        log.warning("Publishing channel not configured yet. Set it from the admin panel.")
+        return
+    try:
+        perms = await client.get_permissions(channel_id, "me")
+        if not perms.post_messages and not perms.is_admin:
+            log.warning("Bot may lack post-message permission in the publishing channel.")
+    except RPCError as e:
+        log.warning("Could not verify channel permissions: %s", e)
+
+    review_group_id = settings.get("review_group_id")
+    if not review_group_id:
+        log.warning("Review group not configured yet. Set it from the admin panel.")
 
 
-# ---------------------------------------------------------------------------
-# التشغيل
-# ---------------------------------------------------------------------------
 async def main():
-    # 1) شغّل البوت التفاعلي (تسجيل دخول بتوكن، بدون أي تفاعل بشري)
-    await bot_client.start(bot_token=BOT_TOKEN)
-    log.info("bot_client متصل (OWNER_ID=%s).", OWNER_ID)
+    log.info("Connecting to MongoDB...")
+    try:
+        await mongo_client.admin.command("ping")
+    except PyMongoError as e:
+        log.error("Could not connect to MongoDB: %s", e)
+        sys.exit(1)
+    log.info("MongoDB connection OK.")
 
-    # 2) أعد الاتصال بحسابات المراقبة المخزنة مسبقًا بـ Mongo
-    for acc in accounts_col.find():
-        try:
-            await connect_account_from_session(acc["phone"], acc["session"])
-            log.info("تم إعادة الاتصال بحساب المراقبة: %s", acc["phone"])
-        except Exception:
-            log.exception("فشل إعادة الاتصال بحساب %s", acc.get("phone"))
+    await ensure_indexes()
+    await get_settings()
 
-    # 3) أعد تفعيل مراقبة القنوات المخزنة، كل وحدة عبر الحساب المسؤول عنها
-    for ch in channels_col.find():
-        client = active_accounts.get(ch.get("account_phone"))
-        if client:
-            await register_channel_monitor(client, ch["channel"])
-        else:
-            log.warning("القناة %s مسجلة على حساب غير متصل حاليًا", ch["channel"])
+    log.info("Starting Telegram client (bot mode)...")
+    await client.start(bot_token=BOT_TOKEN)
+    me = await client.get_me()
+    log.info("Bot connected as @%s (id=%s)", me.username, me.id)
+
+    await check_channel_permissions()
 
-    await bot_client.run_until_disconnected()
+    log.info("MF BLACKLIST bot is up and running.")
+    await client.run_until_disconnected()
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        log.info("Shutting down.")

requirements.txt

@@ -1,8 +1,3 @@
 telethon==1.36.0
+motor==3.5.1
 pymongo==4.8.0
-torch==2.3.1
-open-clip-torch==2.24.0
-pytesseract==0.3.13
-pillow==10.4.0
-numpy==1.26.4
-python-dotenv==1.0.1