Delete database.py

database.py

@@ -1,2606 +0,0 @@
-import json
-import os
-import time
-import shutil
-from threading import Lock
-
-DB_FILE = "/data/data.json"
-BACKUP_DIR = "/data/backups"
-SCHEMA_VERSION = 2
-lock = Lock()
-
-DEFAULT_BLOCKED_WORDS = [
-    "إعلان", "اعلان", "تبادل", "ممول", "تمويل", "للتواصل",
-    "اشتراك", "تابعونا", "اشترك", "قناتنا", "بوت", "عبر البوت",
-    "عرض خاص", "لفترة محدودة", "اضغط هنا", "لمشاهدة المزيد",
-    "حصرياً", "تم النشر بواسطة"
-]
-
-DEFAULT_DATA = {
-    "schema_version": SCHEMA_VERSION,
-    "channels": {},
-    "public_sources": [],
-    "source_meta": {},
-    "blocked_words": DEFAULT_BLOCKED_WORDS,
-    "allowed_users": [],
-    "last_source_messages": {},
-    "settings": {},
-    "global_remove_terms": [],
-    "recent_fingerprints": [],
-    "source_stats": {},
-    "source_logs": {},
-    "system": {},
-    "last_errors": [],
-    "named_backups": [],
-    "channel_failures": {},
-    "published_messages": {},
-    "sessions": {},
-    "ai_keys": {},
-    "publishing_bots": {},
-    "websites": {},
-    "trash": [],
-    "naming_counters": {"session": 0, "ai_key": 0, "bot": 0, "website": 0},
-    "channel_configs": {},
-    "settings_clipboard": None,
-    "_migrated_channel_word_lists": False,
-    "notification_settings": {
-        "session_stopped": True,
-        "ai_key_error": True,
-        "source_stopped": True,
-        "channel_idle_hour": True,
-        "backup_failed": True,
-        "db_issue": True,
-        "last_alert_ts": {},
-    },
-}
-
-
-def _now():
-    return int(time.time())
-
-
-def _dedupe_int_list(values):
-    out = []
-    seen = set()
-    for value in values or []:
-        try:
-            item = int(value)
-        except Exception:
-            item = value
-        key = str(item)
-        if key not in seen:
-            seen.add(key)
-            out.append(item)
-    return out
-
-
-def _normalize_channel(cid, value):
-    if not isinstance(value, dict):
-        value = {"name": str(value)}
-    value.setdefault("name", value.get("title") or str(cid))
-    value.setdefault("title", value.get("name") or str(cid))
-    value.setdefault("username", "")
-    value.setdefault("link", "")
-    value.setdefault("chat_type", "")
-    value.setdefault("tail", "")
-    value.setdefault("special_sources", [])
-    value.setdefault("paused", False)
-    value.setdefault("posts_count", 0)
-    value.setdefault("publish_delay", None)
-    value.setdefault("bold_publish", True)
-    value.setdefault("quote_publish", False)
-    # إعدادات الاقتباس حسب نوع المنشور.
-    # توافق رجعي: إذا كان quote_publish القديم مفعلاً، نفعّل كل الأنواع افتراضياً.
-    old_quote = bool(value.get("quote_publish", False))
-    quote_types = value.get("quote_types")
-    if not isinstance(quote_types, dict):
-        quote_types = {}
-    value["quote_types"] = {
-        "text": bool(quote_types.get("text", old_quote)),
-        "photo": bool(quote_types.get("photo", old_quote)),
-        "video": bool(quote_types.get("video", old_quote)),
-        "album": bool(quote_types.get("album", old_quote)),
-    }
-    # يبقى المفتاح القديم موجود للتوافق مع النسخ الاحتياطية القديمة.
-    value["quote_publish"] = any(value["quote_types"].values())
-    value.setdefault("hashtags", [])
-    if not isinstance(value.get("hashtags"), list):
-        value["hashtags"] = []
-    value.setdefault("fail_count", 0)
-    value.setdefault("disable_web_page_preview", False)
-    value.setdefault("added_at", _now())
-    value.setdefault("tail_enabled", True)
-    value.setdefault("tail_min_words", 20)
-    value.setdefault("tail_position", "bottom")
-    value["special_sources"] = _dedupe_int_list(value.get("special_sources", []))
-    # الكلمات المحظورة وقائمة الحذف الآن مستقلة لكل قناة (وليست عامة).
-    # None = لم تُهاجَر/تُحدَّد بعد؛ تتم معالجتها لاحقاً في _normalize_data.
-    if not isinstance(value.get("blocked_words"), list):
-        value["blocked_words"] = None
-    if not isinstance(value.get("delete_terms"), list):
-        value["delete_terms"] = None
-    return value
-
-
-def _normalize_source_meta(source_id, value=None):
-    if not isinstance(value, dict):
-        value = {}
-    sid = str(source_id)
-    value.setdefault("id", int(source_id) if str(source_id).lstrip('-').isdigit() else source_id)
-    value.setdefault("name", value.get("title") or sid)
-    value.setdefault("title", value.get("name") or sid)
-    value.setdefault("username", "")
-    value.setdefault("link", "")
-    value.setdefault("chat_type", "")
-    value.setdefault("added_at", _now())
-    value.setdefault("paused", False)
-    value.setdefault("remove_terms", [])
-    if not isinstance(value.get("remove_terms"), list):
-        value["remove_terms"] = []
-    value.setdefault("remove_emoji", False)
-    default_types = {"text": True, "photo": True, "video": True, "album": True, "voice": False, "audio": False, "document": False}
-    types = value.get("content_types")
-    if not isinstance(types, dict):
-        types = {}
-    value["content_types"] = {k: bool(types.get(k, v)) for k, v in default_types.items()}
-    return value
-
-
-def _normalize_data(data):
-    if not isinstance(data, dict):
-        data = {}
-
-    for key, value in DEFAULT_DATA.items():
-        if key not in data:
-            data[key] = value.copy() if isinstance(value, (list, dict)) else value
-
-    if not isinstance(data.get("channels"), dict):
-        data["channels"] = {}
-    if not isinstance(data.get("public_sources"), list):
-        data["public_sources"] = []
-    if not isinstance(data.get("source_meta"), dict):
-        data["source_meta"] = {}
-    if not isinstance(data.get("blocked_words"), list):
-        data["blocked_words"] = DEFAULT_BLOCKED_WORDS.copy()
-    if not isinstance(data.get("allowed_users"), list):
-        data["allowed_users"] = []
-    if not isinstance(data.get("last_source_messages"), dict):
-        data["last_source_messages"] = {}
-    if not isinstance(data.get("settings"), dict):
-        data["settings"] = {}
-    if not isinstance(data.get("global_remove_terms"), list):
-        data["global_remove_terms"] = []
-    if not isinstance(data.get("recent_fingerprints"), list):
-        data["recent_fingerprints"] = []
-    if not isinstance(data.get("source_stats"), dict):
-        data["source_stats"] = {}
-    if not isinstance(data.get("source_logs"), dict):
-        data["source_logs"] = {}
-    if not isinstance(data.get("system"), dict):
-        data["system"] = {}
-    if not isinstance(data.get("last_errors"), list):
-        data["last_errors"] = []
-    if not isinstance(data.get("named_backups"), list):
-        data["named_backups"] = []
-    if not isinstance(data.get("channel_failures"), dict):
-        data["channel_failures"] = {}
-    if not isinstance(data.get("published_messages"), dict):
-        data["published_messages"] = {}
-    if not isinstance(data.get("sessions"), dict):
-        data["sessions"] = {}
-    if not isinstance(data.get("ai_keys"), dict):
-        data["ai_keys"] = {}
-    if not isinstance(data.get("publishing_bots"), dict):
-        data["publishing_bots"] = {}
-    if not isinstance(data.get("websites"), dict):
-        data["websites"] = {}
-    if not isinstance(data.get("trash"), list):
-        data["trash"] = []
-    if not isinstance(data.get("naming_counters"), dict):
-        data["naming_counters"] = {"session": 0, "ai_key": 0, "bot": 0, "website": 0}
-    if not isinstance(data.get("channel_configs"), dict):
-        data["channel_configs"] = {}
-    if not isinstance(data.get("notification_settings"), dict):
-        data["notification_settings"] = DEFAULT_DATA["notification_settings"].copy()
-    ns = data["notification_settings"]
-    for k, v in DEFAULT_DATA["notification_settings"].items():
-        ns.setdefault(k, v.copy() if isinstance(v, dict) else v)
-
-    data.setdefault("settings_clipboard", None)
-
-    data["schema_version"] = SCHEMA_VERSION
-    data["public_sources"] = _dedupe_int_list(data.get("public_sources", []))
-
-    channels = {}
-    for cid, ch in data.get("channels", {}).items():
-        channels[str(cid)] = _normalize_channel(cid, ch)
-    data["channels"] = channels
-
-    # هجرة لمرة واحدة: نسخ القوائم العامة القديمة (الكلمات المحظورة / قائمة
-    # الحذف العامة) داخل كل قناة موجودة حتى تصبح كل قناة مستقلة بقوائمها،
-    # بدون فقدان البيانات القديمة. تعمل مرة وحدة فقط بفضل العلم أدناه، حتى
-    # القنوات التي تُفرّغ قوائمها لاحقاً ما تنرجع تنعبي من جديد.
-    if not data.get("_migrated_channel_word_lists"):
-        legacy_blocked = data.get("blocked_words") or DEFAULT_BLOCKED_WORDS.copy()
-        legacy_terms = data.get("global_remove_terms") or []
-        for ch in data["channels"].values():
-            if ch.get("blocked_words") is None:
-                ch["blocked_words"] = list(legacy_blocked)
-            if ch.get("delete_terms") is None:
-                ch["delete_terms"] = list(legacy_terms)
-        data["_migrated_channel_word_lists"] = True
-
-    # أي قناة بلا قيمة بعد (مثلاً أُضيفت حديثاً بعد الهجرة) تاخذ افتراضي فارغ/عام.
-    for ch in data["channels"].values():
-        if ch.get("blocked_words") is None:
-            ch["blocked_words"] = DEFAULT_BLOCKED_WORDS.copy()
-        if ch.get("delete_terms") is None:
-            ch["delete_terms"] = []
-
-    meta = {}
-    for source in data["public_sources"]:
-        sid = str(source)
-        meta[sid] = _normalize_source_meta(source, data.get("source_meta", {}).get(sid, {}))
-    for sid, value in data.get("source_meta", {}).items():
-        if sid not in meta:
-            meta[sid] = _normalize_source_meta(sid, value)
-    data["source_meta"] = meta
-
-    # normalize last source ids as strings
-    data["last_source_messages"] = {str(k): v for k, v in data.get("last_source_messages", {}).items()}
-    return data
-
-
-
-def _is_valid_data(data, allow_empty=True):
-    """يتأكد أن ملف البيانات صالح وليس فارغاً/تالفاً."""
-    if not isinstance(data, dict):
-        return False
-    if "channels" not in data or "public_sources" not in data:
-        return False
-    if not isinstance(data.get("channels"), dict):
-        return False
-    if not isinstance(data.get("public_sources"), list):
-        return False
-    if not allow_empty:
-        if not data.get("channels") and not data.get("public_sources") and not data.get("source_meta"):
-            return False
-    return True
-
-
-def _load_json_file(path):
-    with open(path, "r", encoding="utf-8") as f:
-        data = json.load(f)
-    if not _is_valid_data(data, allow_empty=True):
-        raise ValueError("ملف بيانات غير صالح")
-    return _normalize_data(data)
-
-
-def _backup_candidates():
-    files = []
-    if os.path.exists(DB_FILE + ".bak"):
-        files.append(DB_FILE + ".bak")
-    if os.path.isdir(BACKUP_DIR):
-        files.extend(
-            os.path.join(BACKUP_DIR, x)
-            for x in os.listdir(BACKUP_DIR)
-            if x.endswith(".json")
-        )
-    return sorted(files, key=lambda p: os.path.getmtime(p), reverse=True)
-
-
-def _restore_latest_backup():
-    """يحاول استعادة أحدث نسخة احتياطية صالحة."""
-    os.makedirs("/data", exist_ok=True)
-    for path in _backup_candidates():
-        try:
-            data = _load_json_file(path)
-            tmp = DB_FILE + ".restore.tmp"
-            with open(tmp, "w", encoding="utf-8") as f:
-                json.dump(data, f, ensure_ascii=False, indent=2)
-            os.replace(tmp, DB_FILE)
-            return data
-        except Exception:
-            continue
-    return None
-
-
-def verify_or_recover_storage():
-    """فحص تخزين آمن عند تشغيل التطبيق/البوت."""
-    os.makedirs("/data", exist_ok=True)
-    if os.path.exists(DB_FILE):
-        try:
-            data = _load_json_file(DB_FILE)
-            return {"ok": True, "recovered": False, "message": "data.json صالح", "data": data}
-        except Exception as e:
-            recovered = _restore_latest_backup()
-            if recovered is not None:
-                return {"ok": True, "recovered": True, "message": f"تمت الاستعادة من Backup بعد تلف data.json: {e}", "data": recovered}
-            return {"ok": False, "recovered": False, "message": f"data.json تالف ولا توجد نسخة احتياطية صالحة: {e}", "data": None}
-
-    recovered = _restore_latest_backup()
-    if recovered is not None:
-        return {"ok": True, "recovered": True, "message": "تمت الاستعادة من Backup لأن data.json غير موجود", "data": recovered}
-
-    # أول تشغيل فقط: إنشاء ملف جديد فارغ
-    data = _normalize_data(DEFAULT_DATA.copy())
-    with open(DB_FILE, "w", encoding="utf-8") as f:
-        json.dump(data, f, ensure_ascii=False, indent=2)
-    return {"ok": True, "recovered": False, "message": "تم إنشاء قاعدة بيانات جديدة", "data": data}
-
-
-def _read():
-    os.makedirs("/data", exist_ok=True)
-    status = verify_or_recover_storage()
-    if not status.get("ok"):
-        raise RuntimeError(status.get("message", "فشل قراءة قاعدة البيانات"))
-    return _normalize_data(status.get("data") or DEFAULT_DATA.copy())
-
-
-def _make_prewrite_backup():
-    """نسخة احتياطية فورية قبل أي كتابة حتى لا تضيع البيانات عند توقف الاستضافة."""
-    try:
-        if os.path.exists(DB_FILE) and os.path.getsize(DB_FILE) > 5:
-            shutil.copy2(DB_FILE, DB_FILE + ".bak")
-    except Exception:
-        pass
-
-
-def _write(data):
-    os.makedirs("/data", exist_ok=True)
-    data = _normalize_data(data)
-
-    # حماية من الكتابة بملف فارغ فوق بيانات موجودة
-    if not _is_valid_data(data, allow_empty=True):
-        raise ValueError("رفض كتابة بيانات غير صالحة")
-
-    _make_prewrite_backup()
-    tmp_file = DB_FILE + ".tmp"
-    with open(tmp_file, "w", encoding="utf-8") as f:
-        json.dump(data, f, ensure_ascii=False, indent=2)
-        f.flush()
-        try:
-            os.fsync(f.fileno())
-        except Exception:
-            pass
-    os.replace(tmp_file, DB_FILE)
-
-
-def _write_backup(data):
-    try:
-        os.makedirs(BACKUP_DIR, exist_ok=True)
-        data = _normalize_data(data)
-        if not _is_valid_data(data, allow_empty=True):
-            return
-        backup_file = os.path.join(BACKUP_DIR, f"backup_{int(time.time())}.json")
-        with open(backup_file, "w", encoding="utf-8") as f:
-            json.dump(data, f, ensure_ascii=False, indent=2)
-        # keep last 20 backups
-        files = sorted([os.path.join(BACKUP_DIR, x) for x in os.listdir(BACKUP_DIR) if x.endswith('.json')])
-        for old in files[:-20]:
-            try:
-                os.remove(old)
-            except Exception:
-                pass
-    except Exception:
-        pass
-
-def get_all_channels():
-    with lock:
-        data = _read()
-    return [{"id": k, **v} for k, v in data["channels"].items()]
-
-
-def add_channel(channel_id, name="", title="", username="", link="", chat_type=""):
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-        created = cid not in data["channels"]
-        if created:
-            data["channels"][cid] = _normalize_channel(cid, {
-                "name": title or name or cid,
-                "title": title or name or cid,
-                "username": username or "",
-                "link": link or "",
-                "chat_type": chat_type or "",
-                "tail": "",
-                "special_sources": [],
-                "paused": False,
-                "posts_count": 0,
-                "added_at": _now(),
-            })
-        else:
-            ch = data["channels"][cid]
-            if title or name:
-                ch["name"] = title or name
-                ch["title"] = title or name
-            if username is not None:
-                ch["username"] = username or ch.get("username", "")
-            if link is not None:
-                ch["link"] = link or ch.get("link", "")
-            if chat_type is not None:
-                ch["chat_type"] = chat_type or ch.get("chat_type", "")
-        _write(data)
-        if created:
-            _write_backup(data)
-        return created
-
-
-def delete_channel(channel_id):
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-        if cid in data["channels"]:
-            del data["channels"][cid]
-            _write(data)
-            _write_backup(data)
-            return True
-    return False
-
-
-def update_channel(channel_id, key, value):
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-        if cid in data["channels"]:
-            data["channels"][cid][key] = value
-            _write(data)
-            _write_backup(data)
-            return True
-    return False
-
-
-def increment_post_count(channel_id):
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-        if cid in data["channels"]:
-            data["channels"][cid].setdefault("posts_count", 0)
-            data["channels"][cid]["posts_count"] += 1
-            _write(data)
-            return True
-    return False
-
-
-def get_channel(channel_id):
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-    return data["channels"].get(cid)
-
-
-def get_public_sources():
-    with lock:
-        data = _read()
-    return data["public_sources"]
-
-
-def get_source_meta(source_id):
-    sid = str(source_id)
-    with lock:
-        data = _read()
-    return data.get("source_meta", {}).get(sid, _normalize_source_meta(source_id))
-
-
-def get_all_public_sources_with_meta():
-    with lock:
-        data = _read()
-    return [{"id": s, **data.get("source_meta", {}).get(str(s), _normalize_source_meta(s))} for s in data["public_sources"]]
-
-
-def add_public_source(source_id, name="", title="", username="", link="", chat_type=""):
-    try:
-        source_id = int(source_id)
-    except Exception:
-        pass
-    sid = str(source_id)
-
-    with lock:
-        data = _read()
-        created = source_id not in data["public_sources"]
-        if created:
-            data["public_sources"].append(source_id)
-        old = data.setdefault("source_meta", {}).get(sid, {})
-        meta = _normalize_source_meta(source_id, old)
-        if title or name:
-            meta["name"] = title or name
-            meta["title"] = title or name
-        if username is not None:
-            meta["username"] = username or meta.get("username", "")
-        if link is not None:
-            meta["link"] = link or meta.get("link", "")
-        if chat_type is not None:
-            meta["chat_type"] = chat_type or meta.get("chat_type", "")
-        data["source_meta"][sid] = meta
-        _write(data)
-        if created:
-            _write_backup(data)
-        return created
-
-
-def update_source_meta(source_id, **kwargs):
-    sid = str(source_id)
-    with lock:
-        data = _read()
-        meta = _normalize_source_meta(source_id, data.setdefault("source_meta", {}).get(sid, {}))
-        for key, value in kwargs.items():
-            if value is not None:
-                meta[key] = value
-        data["source_meta"][sid] = meta
-        _write(data)
-        return True
-
-
-def remove_public_source(source_id):
-    try:
-        source_id = int(source_id)
-    except Exception:
-        pass
-    sid = str(source_id)
-
-    with lock:
-        data = _read()
-        if source_id in data["public_sources"]:
-            data["public_sources"].remove(source_id)
-            data["last_source_messages"].pop(sid, None)
-            data.get("source_meta", {}).pop(sid, None)
-            _write(data)
-            _write_backup(data)
-            return True
-    return False
-
-
-def get_blocked_words():
-    with lock:
-        data = _read()
-    return data["blocked_words"]
-
-
-def add_blocked_word(word):
-    word = str(word).strip()
-    if not word:
-        return False
-    with lock:
-        data = _read()
-        if word not in data["blocked_words"]:
-            data["blocked_words"].append(word)
-            _write(data)
-            _write_backup(data)
-            return True
-    return False
-
-
-def remove_blocked_word(word):
-    word = str(word).strip()
-    with lock:
-        data = _read()
-        if word in data["blocked_words"]:
-            data["blocked_words"].remove(word)
-            _write(data)
-            _write_backup(data)
-            return True
-    return False
-
-
-# ============================================================
-# الكلمات المحظورة / قائمة الحذف — مستقلة لكل قناة
-# ============================================================
-
-def get_channel_blocked_words(channel_id):
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-        ch = data["channels"].get(cid)
-        return list(ch.get("blocked_words", [])) if ch else []
-
-
-def add_channel_blocked_word(channel_id, word):
-    word = str(word).strip()
-    if not word:
-        return False
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-        ch = data["channels"].get(cid)
-        if not ch:
-            return False
-        ch.setdefault("blocked_words", [])
-        if word not in ch["blocked_words"]:
-            ch["blocked_words"].append(word)
-            _write(data)
-            _write_backup(data)
-            return True
-    return False
-
-
-def remove_channel_blocked_word(channel_id, word):
-    word = str(word).strip()
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-        ch = data["channels"].get(cid)
-        if not ch:
-            return False
-        if word in ch.get("blocked_words", []):
-            ch["blocked_words"].remove(word)
-            _write(data)
-            _write_backup(data)
-            return True
-    return False
-
-
-def get_channel_delete_terms(channel_id):
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-        ch = data["channels"].get(cid)
-        return list(ch.get("delete_terms", [])) if ch else []
-
-
-def add_channel_delete_terms(channel_id, terms):
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-        ch = data["channels"].get(cid)
-        if not ch:
-            return {"added": 0, "exists": 0}
-        existing = [str(x).strip() for x in ch.get("delete_terms", []) if str(x).strip()]
-        added = 0
-        exists = 0
-        for term in terms:
-            term = str(term).strip()
-            if not term:
-                continue
-            if term in existing:
-                exists += 1
-            else:
-                existing.append(term)
-                added += 1
-        ch["delete_terms"] = existing
-        _write(data)
-        _write_backup(data)
-    return {"added": added, "exists": exists}
-
-
-def remove_channel_delete_terms(channel_id, terms):
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-        ch = data["channels"].get(cid)
-        if not ch:
-            return {"removed": 0, "missing": 0}
-        existing = [str(x).strip() for x in ch.get("delete_terms", []) if str(x).strip()]
-        removed = 0
-        missing = 0
-        for term in terms:
-            term = str(term).strip()
-            if term in existing:
-                existing.remove(term)
-                removed += 1
-            else:
-                missing += 1
-        ch["delete_terms"] = existing
-        _write(data)
-        _write_backup(data)
-    return {"removed": removed, "missing": missing}
-
-
-def get_last_source_message(source_id):
-    with lock:
-        data = _read()
-    value = data.get("last_source_messages", {}).get(str(source_id))
-    try:
-        if isinstance(value, dict):
-            return int(value.get("id")) if value.get("id") is not None else None
-        return int(value) if value is not None else None
-    except Exception:
-        return None
-
-def set_last_source_message(source_id, message_id):
-    with lock:
-        data = _read()
-        data.setdefault("last_source_messages", {})[str(source_id)] = {"id": int(message_id), "ts": _now()}
-        _write(data)
-        return True
-
-def reset_last_source_message(source_id):
-    with lock:
-        data = _read()
-        if str(source_id) in data.get("last_source_messages", {}):
-            del data["last_source_messages"][str(source_id)]
-            _write(data)
-            _write_backup(data)
-            return True
-    return False
-
-
-
-def export_data():
-    with lock:
-        data = _read()
-    data = cleanup_old_runtime_data(data, days=3)
-    return json.dumps(_normalize_data(data), ensure_ascii=False, indent=2)
-
-
-def import_data(json_str):
-    with lock:
-        new_data = json.loads(json_str)
-        if not _is_valid_data(new_data, allow_empty=False):
-            raise ValueError("ملف الاستيراد فارغ أو غير صالح. تم رفضه لحماية بياناتك.")
-        new_data = _normalize_data(new_data)
-
-        # لا نقبل ملف بلا قنوات وبلا مصادر إلا إذا كان مقصوداً، وهذا غير مسموح هنا
-        if not new_data.get("channels") and not new_data.get("public_sources") and not new_data.get("source_meta"):
-            raise ValueError("ملف الاستيراد لا يحتوي قنوات أو مصادر.")
-
-        _make_prewrite_backup()
-        _write_backup(_read())
-        new_data = cleanup_old_runtime_data(new_data, days=3)
-        _write(new_data)
-        _write_backup(new_data)
-        return {
-            "channels": len(new_data.get("channels", {})),
-            "public_sources": len(new_data.get("public_sources", [])),
-            "source_meta": len(new_data.get("source_meta", {})),
-            "blocked_words": len(new_data.get("blocked_words", [])),
-            "global_remove_terms": len(new_data.get("global_remove_terms", [])),
-            "last_source_messages": len(new_data.get("last_source_messages", {})),
-            "recent_fingerprints": len(new_data.get("recent_fingerprints", [])),
-        }
-
-
-def cleanup_old_runtime_data(data=None, days=3):
-    """حذف بيانات التكرار والسجلات و IDs المؤقتة الأقدم من 3 أيام حتى لا يكبر الملف."""
-    cutoff = _now() - int(days) * 86400
-    own_write = data is None
-    if data is None:
-        data = _read()
-
-    items = data.get("recent_fingerprints", [])
-    if isinstance(items, list):
-        data["recent_fingerprints"] = [
-            x for x in items
-            if isinstance(x, dict) and int(x.get("ts", _now())) >= cutoff
-        ][-500:]
-
-    logs = data.get("source_logs", {})
-    if isinstance(logs, dict):
-        new_logs = {}
-        for sid, entries in logs.items():
-            if isinstance(entries, list):
-                new_logs[sid] = [
-                    x for x in entries
-                    if isinstance(x, dict) and int(x.get("ts", _now())) >= cutoff
-                ][-20:]
-        data["source_logs"] = new_logs
-
-    # تنظيف IDs آخر الأخبار للمصادر إذا خزنّت بصيغة حديثة مع تاريخ.
-    # القيم القديمة الرقمية تُترك كما هي للتوافق حتى يتم تحديثها تلقائياً عند أول فحص.
-    last_ids = data.get("last_source_messages", {})
-    if isinstance(last_ids, dict):
-        cleaned_last = {}
-        for sid, value in last_ids.items():
-            if isinstance(value, dict):
-                try:
-                    if int(value.get("ts", _now())) >= cutoff:
-                        cleaned_last[str(sid)] = value
-                except Exception:
-                    pass
-            else:
-                cleaned_last[str(sid)] = value
-        data["last_source_messages"] = cleaned_last
-
-    last_errors = data.get("last_errors", [])
-    if isinstance(last_errors, list):
-        data["last_errors"] = [
-            x for x in last_errors
-            if isinstance(x, dict) and int(x.get("ts", _now())) >= cutoff
-        ][-50:]
-
-
-    # تنظيف سجل الرسائل المنشورة القديمة حتى لا يكبر الملف.
-    published = data.get("published_messages", {})
-    if isinstance(published, dict):
-        new_published = {}
-        for cid, by_type in published.items():
-            if not isinstance(by_type, dict):
-                continue
-            new_by_type = {}
-            for kind, entries in by_type.items():
-                if isinstance(entries, list):
-                    new_by_type[kind] = [
-                        x for x in entries
-                        if isinstance(x, dict) and int(x.get("ts", _now())) >= cutoff
-                    ][-1000:]
-            new_published[str(cid)] = new_by_type
-        data["published_messages"] = new_published
-
-    if own_write:
-        _write(data)
-    return _normalize_data(data)
-
-def get_source_remove_terms(source_id):
-    sid = str(source_id)
-    with lock:
-        data = _read()
-    meta = data.get("source_meta", {}).get(sid, _normalize_source_meta(source_id))
-    terms = meta.get("remove_terms", [])
-    if not isinstance(terms, list):
-        return []
-    return [str(x).strip() for x in terms if str(x).strip()]
-
-
-def add_source_remove_terms(source_id, terms):
-    sid = str(source_id)
-    clean_terms = []
-    for term in terms or []:
-        term = str(term).strip()
-        if term:
-            clean_terms.append(term)
-
-    if not clean_terms:
-        return {"added": 0, "exists": 0}
-
-    with lock:
-        data = _read()
-        meta = _normalize_source_meta(source_id, data.setdefault("source_meta", {}).get(sid, {}))
-        existing = [str(x).strip() for x in meta.get("remove_terms", []) if str(x).strip()]
-        existing_keys = {x.lower() for x in existing}
-
-        added = 0
-        exists = 0
-        for term in clean_terms:
-            key = term.lower()
-            if key in existing_keys:
-                exists += 1
-                continue
-            existing.append(term)
-            existing_keys.add(key)
-            added += 1
-
-        meta["remove_terms"] = existing
-        data["source_meta"][sid] = meta
-        _write(data)
-        if added:
-            _write_backup(data)
-    return {"added": added, "exists": exists}
-
-
-def remove_source_remove_terms(source_id, terms):
-    sid = str(source_id)
-    remove_keys = {str(x).strip().lower() for x in terms or [] if str(x).strip()}
-    if not remove_keys:
-        return {"removed": 0, "missing": 0}
-
-    with lock:
-        data = _read()
-        meta = _normalize_source_meta(source_id, data.setdefault("source_meta", {}).get(sid, {}))
-        existing = [str(x).strip() for x in meta.get("remove_terms", []) if str(x).strip()]
-        before = len(existing)
-        existing = [x for x in existing if x.lower() not in remove_keys]
-        removed = before - len(existing)
-        meta["remove_terms"] = existing
-        data["source_meta"][sid] = meta
-        _write(data)
-        if removed:
-            _write_backup(data)
-    return {"removed": removed, "missing": max(0, len(remove_keys) - removed)}
-
-
-def remove_source_remove_term(source_id, term_or_index):
-    terms = get_source_remove_terms(source_id)
-    try:
-        idx = int(term_or_index)
-        if 0 <= idx < len(terms):
-            return bool(remove_source_remove_terms(source_id, [terms[idx]]).get("removed"))
-    except Exception:
-        pass
-    return bool(remove_source_remove_terms(source_id, [term_or_index]).get("removed"))
-
-
-# ===== Phase 3 Part 1: source filters, global cleanup, smart dedupe =====
-def get_global_remove_terms():
-    with lock:
-        data = _read()
-    terms = data.get("global_remove_terms", [])
-    if not isinstance(terms, list):
-        return []
-    return [str(x).strip() for x in terms if str(x).strip()]
-
-
-def add_global_remove_terms(terms):
-    clean_terms = []
-    for term in terms or []:
-        term = str(term).strip()
-        if term:
-            clean_terms.append(term)
-
-    if not clean_terms:
-        return {"added": 0, "exists": 0}
-
-    with lock:
-        data = _read()
-        existing = [str(x).strip() for x in data.get("global_remove_terms", []) if str(x).strip()]
-        existing_keys = {x.lower() for x in existing}
-        added = 0
-        exists = 0
-        for term in clean_terms:
-            key = term.lower()
-            if key in existing_keys:
-                exists += 1
-                continue
-            existing.append(term)
-            existing_keys.add(key)
-            added += 1
-        data["global_remove_terms"] = existing
-        _write(data)
-        if added:
-            _write_backup(data)
-    return {"added": added, "exists": exists}
-
-
-def remove_global_remove_terms(terms):
-    remove_keys = {str(x).strip().lower() for x in terms or [] if str(x).strip()}
-    if not remove_keys:
-        return {"removed": 0, "missing": 0}
-
-    with lock:
-        data = _read()
-        existing = [str(x).strip() for x in data.get("global_remove_terms", []) if str(x).strip()]
-        before = len(existing)
-        existing = [x for x in existing if x.lower() not in remove_keys]
-        removed = before - len(existing)
-        data["global_remove_terms"] = existing
-        _write(data)
-        if removed:
-            _write_backup(data)
-    return {"removed": removed, "missing": max(0, len(remove_keys) - removed)}
-
-
-def set_source_paused(source_id, paused=True):
-    return update_source_meta(source_id, paused=bool(paused))
-
-
-def is_source_paused(source_id):
-    sid = str(source_id)
-    with lock:
-        data = _read()
-    meta = data.get("source_meta", {}).get(sid, _normalize_source_meta(source_id))
-    return bool(meta.get("paused", False))
-
-
-def set_source_remove_emoji(source_id, enabled=True):
-    return update_source_meta(source_id, remove_emoji=bool(enabled))
-
-
-def get_source_remove_emoji(source_id):
-    sid = str(source_id)
-    with lock:
-        data = _read()
-    meta = data.get("source_meta", {}).get(sid, _normalize_source_meta(source_id))
-    return bool(meta.get("remove_emoji", False))
-
-
-def get_source_content_types(source_id):
-    sid = str(source_id)
-    with lock:
-        data = _read()
-    meta = data.get("source_meta", {}).get(sid, _normalize_source_meta(source_id))
-    default_types = {"text": True, "photo": True, "video": True, "album": True, "voice": False, "audio": False, "document": False}
-    types = meta.get("content_types", {})
-    if not isinstance(types, dict):
-        types = {}
-    return {k: bool(types.get(k, v)) for k, v in default_types.items()}
-
-
-def set_source_content_type(source_id, content_type, enabled=True):
-    if content_type not in {"text", "photo", "video", "album", "voice", "audio", "document"}:
-        return False
-    sid = str(source_id)
-    default_types = {"text": True, "photo": True, "video": True, "album": True, "voice": False, "audio": False, "document": False}
-    with lock:
-        data = _read()
-        meta = _normalize_source_meta(source_id, data.setdefault("source_meta", {}).get(sid, {}))
-        current = meta.get("content_types", {})
-        if not isinstance(current, dict):
-            current = {}
-        types = {k: bool(current.get(k, v)) for k, v in default_types.items()}
-        types[content_type] = bool(enabled)
-        # منع إطفاء كل الأنواع حتى لا يصبح المصدر شغال بلا أي محتوى
-        if not any(types.values()):
-            return False
-        meta["content_types"] = types
-        data["source_meta"][sid] = meta
-        _write(data)
-        _write_backup(data)
-        return True
-
-
-def set_source_content_types(source_id, content_types):
-    allowed = {"text", "photo", "video", "album", "voice", "audio", "document"}
-    values = {k: bool(content_types.get(k, False)) for k in allowed}
-    if not any(values.values()):
-        return False
-    return update_source_meta(source_id, content_types=values)
-
-
-def get_recent_fingerprints():
-    cutoff = _now() - 3 * 86400
-    with lock:
-        data = _read()
-        items = data.get("recent_fingerprints", [])
-        if not isinstance(items, list):
-            return []
-        fresh = [x for x in items if isinstance(x, dict) and x.get("fp") and int(x.get("ts", _now())) >= cutoff]
-        if len(fresh) != len(items):
-            data["recent_fingerprints"] = fresh[-500:]
-            _write(data)
-        return fresh[-500:]
-
-def add_recent_fingerprint(fp, sample="", limit=500):
-    fp = str(fp or "").strip()
-    if not fp:
-        return False
-    cutoff = _now() - 3 * 86400
-    with lock:
-        data = _read()
-        items = data.get("recent_fingerprints", [])
-        if not isinstance(items, list):
-            items = []
-        items = [x for x in items if isinstance(x, dict) and x.get("fp") != fp and int(x.get("ts", _now())) >= cutoff]
-        items.append({"fp": fp, "sample": str(sample or "")[:500], "ts": _now()})
-        if len(items) > int(limit):
-            items = items[-int(limit):]
-        data["recent_fingerprints"] = items
-        _write(data)
-        return True
-
-def set_channel_publish_delay(channel_id, delay_seconds):
-    try:
-        if delay_seconds is None or str(delay_seconds).strip() == "":
-            value = None
-        else:
-            value = max(0.0, float(delay_seconds))
-    except Exception:
-        return False
-    return update_channel(channel_id, "publish_delay", value)
-
-
-def get_channel_publish_delay(channel_id, default=0.5):
-    ch = get_channel(channel_id)
-    if not ch:
-        return float(default)
-    value = ch.get("publish_delay", None)
-    if value is None or value == "":
-        return float(default)
-    try:
-        return max(0.0, float(value))
-    except Exception:
-        return float(default)
-
-
-
-def set_channel_bold_publish(channel_id, enabled=True):
-    return update_channel(channel_id, "bold_publish", bool(enabled))
-
-
-def get_channel_bold_publish(channel_id, default=True):
-    ch = get_channel(channel_id)
-    if not ch:
-        return bool(default)
-    return bool(ch.get("bold_publish", default))
-
-def record_source_event(source_id, event_type, reason="", message_id=None, target_count=0):
-    sid = str(source_id)
-    with lock:
-        data = _read()
-        stats = data.setdefault("source_stats", {}).setdefault(sid, {
-            "received": 0, "published": 0, "rejected": 0, "ignored": 0,
-            "duplicates": 0, "errors": 0, "last_message_id": None,
-            "last_event": "", "last_reason": "", "last_ts": None
-        })
-        event_type = str(event_type or "").lower()
-        if event_type == "received":
-            stats["received"] = int(stats.get("received", 0)) + 1
-        elif event_type == "published":
-            stats["published"] = int(stats.get("published", 0)) + 1
-        elif event_type == "rejected":
-            stats["rejected"] = int(stats.get("rejected", 0)) + 1
-        elif event_type == "duplicate":
-            stats["duplicates"] = int(stats.get("duplicates", 0)) + 1
-            stats["ignored"] = int(stats.get("ignored", 0)) + 1
-        elif event_type == "error":
-            stats["errors"] = int(stats.get("errors", 0)) + 1
-        else:
-            stats["ignored"] = int(stats.get("ignored", 0)) + 1
-        stats["last_message_id"] = message_id
-        stats["last_event"] = event_type
-        stats["last_reason"] = str(reason or "")[:300]
-        stats["last_ts"] = _now()
-        data["source_stats"][sid] = stats
-
-        logs = data.setdefault("source_logs", {}).setdefault(sid, [])
-        logs.append({
-            "ts": _now(), "event": event_type, "reason": str(reason or "")[:300],
-            "message_id": message_id, "target_count": int(target_count or 0)
-        })
-        data["source_logs"][sid] = logs[-20:]
-        _write(data)
-        return True
-
-
-def get_source_stats(source_id):
-    sid = str(source_id)
-    with lock:
-        data = _read()
-    return data.get("source_stats", {}).get(sid, {
-        "received": 0, "published": 0, "rejected": 0, "ignored": 0,
-        "duplicates": 0, "errors": 0, "last_message_id": None,
-        "last_event": "", "last_reason": "", "last_ts": None
-    })
-
-
-def get_source_logs(source_id, limit=20):
-    sid = str(source_id)
-    with lock:
-        data = _read()
-    logs = data.get("source_logs", {}).get(sid, [])
-    if not isinstance(logs, list):
-        return []
-    return logs[-int(limit):]
-
-
-def copy_source_settings(from_source_id, to_source_ids):
-    from_sid = str(from_source_id)
-    copied = 0
-    with lock:
-        data = _read()
-        source_meta = _normalize_source_meta(from_source_id, data.setdefault("source_meta", {}).get(from_sid, {}))
-        keys = ["remove_terms", "remove_emoji", "content_types", "paused"]
-        for dst in to_source_ids or []:
-            sid = str(dst)
-            meta = _normalize_source_meta(dst, data.setdefault("source_meta", {}).get(sid, {}))
-            for key in keys:
-                if key in source_meta:
-                    # copy JSON-compatible value
-                    meta[key] = json.loads(json.dumps(source_meta[key], ensure_ascii=False))
-            data["source_meta"][sid] = meta
-            copied += 1
-        _write(data)
-        if copied:
-            _write_backup(data)
-    return copied
-
-
-def set_system_value(key, value):
-    with lock:
-        data = _read()
-        data.setdefault("system", {})[str(key)] = value
-        _write(data)
-        return True
-
-
-def get_system_value(key, default=None):
-    with lock:
-        data = _read()
-    return data.get("system", {}).get(str(key), default)
-
-
-# ===== Professional safety/ops additions =====
-def is_maintenance_mode():
-    with lock:
-        data = _read()
-    return bool(data.get("system", {}).get("maintenance_mode", False))
-
-
-def set_maintenance_mode(enabled):
-    with lock:
-        data = _read()
-        data.setdefault("system", {})["maintenance_mode"] = bool(enabled)
-        data["system"]["maintenance_updated_at"] = _now()
-        _write(data)
-        return True
-
-
-def add_last_error(context, error):
-    with lock:
-        data = _read()
-        errors = data.setdefault("last_errors", [])
-        if not isinstance(errors, list):
-            errors = []
-        errors.append({
-            "ts": _now(),
-            "context": str(context or "")[:120],
-            "error": str(error or "")[:500],
-        })
-        data["last_errors"] = errors[-20:]
-        data.setdefault("system", {})["last_error"] = f"{context}: {error}"[:600]
-        data["system"]["last_error_ts"] = _now()
-        _write(data)
-        return True
-
-
-def get_last_errors(limit=20):
-    with lock:
-        data = _read()
-    errors = data.get("last_errors", [])
-    if not isinstance(errors, list):
-        return []
-    return errors[-int(limit):]
-
-
-def clear_last_errors():
-    with lock:
-        data = _read()
-        data["last_errors"] = []
-        data.setdefault("system", {})["last_error"] = ""
-        _write(data)
-        return True
-
-
-def _normalize_quote_types(value=None, fallback=False):
-    if not isinstance(value, dict):
-        value = {}
-    return {
-        "text": bool(value.get("text", fallback)),
-        "photo": bool(value.get("photo", fallback)),
-        "video": bool(value.get("video", fallback)),
-        "album": bool(value.get("album", fallback)),
-    }
-
-
-def set_channel_quote_publish(channel_id, enabled=True):
-    # المفتاح القديم: يبدّل كل الأنواع مرة واحدة للتوافق فقط.
-    cid = str(channel_id)
-    enabled = bool(enabled)
-    with lock:
-        data = _read()
-        if cid not in data.get("channels", {}):
-            return False
-        data["channels"][cid]["quote_types"] = _normalize_quote_types({}, enabled)
-        data["channels"][cid]["quote_publish"] = enabled
-        _write(data)
-        _write_backup(data)
-        return True
-
-
-def get_channel_quote_publish(channel_id, default=False):
-    ch = get_channel(channel_id)
-    if not ch:
-        return bool(default)
-    qt = _normalize_quote_types(ch.get("quote_types"), ch.get("quote_publish", default))
-    return any(qt.values())
-
-
-def get_channel_quote_types(channel_id):
-    ch = get_channel(channel_id)
-    if not ch:
-        return _normalize_quote_types({}, False)
-    return _normalize_quote_types(ch.get("quote_types"), ch.get("quote_publish", False))
-
-
-def get_channel_quote_type(channel_id, content_type="text", default=False):
-    ctype = str(content_type or "text")
-    if ctype not in {"text", "photo", "video", "album"}:
-        ctype = "text"
-    return bool(get_channel_quote_types(channel_id).get(ctype, default))
-
-
-def set_channel_quote_type(channel_id, content_type, enabled=True):
-    cid = str(channel_id)
-    ctype = str(content_type or "text")
-    if ctype not in {"text", "photo", "video", "album"}:
-        return False
-    with lock:
-        data = _read()
-        if cid not in data.get("channels", {}):
-            return False
-        ch = data["channels"][cid]
-        qt = _normalize_quote_types(ch.get("quote_types"), ch.get("quote_publish", False))
-        qt[ctype] = bool(enabled)
-        ch["quote_types"] = qt
-        ch["quote_publish"] = any(qt.values())
-        _write(data)
-        _write_backup(data)
-        return True
-
-
-def get_channel_hashtags(channel_id):
-    ch = get_channel(channel_id)
-    if not ch:
-        return []
-    tags = ch.get("hashtags", [])
-    if not isinstance(tags, list):
-        return []
-    out = []
-    seen = set()
-    for tag in tags:
-        tag = str(tag).strip()
-        if not tag:
-            continue
-        if not tag.startswith("#"):
-            tag = "#" + tag.lstrip("#")
-        key = tag.lower()
-        if key not in seen:
-            seen.add(key)
-            out.append(tag)
-    return out
-
-
-def add_channel_hashtags(channel_id, tags):
-    clean = []
-    for tag in tags or []:
-        tag = str(tag).strip()
-        if not tag:
-            continue
-        if not tag.startswith("#"):
-            tag = "#" + tag.lstrip("#")
-        clean.append(tag)
-    if not clean:
-        return {"added": 0, "exists": 0}
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-        if cid not in data["channels"]:
-            return {"added": 0, "exists": 0}
-        existing = []
-        for tag in data["channels"][cid].get("hashtags", []):
-            tag = str(tag).strip()
-            if tag:
-                existing.append(tag if tag.startswith("#") else "#" + tag.lstrip("#"))
-        keys = {x.lower() for x in existing}
-        added = 0
-        exists = 0
-        for tag in clean:
-            key = tag.lower()
-            if key in keys:
-                exists += 1
-                continue
-            existing.append(tag)
-            keys.add(key)
-            added += 1
-        data["channels"][cid]["hashtags"] = existing
-        _write(data)
-        if added:
-            _write_backup(data)
-        return {"added": added, "exists": exists}
-
-
-def remove_channel_hashtags(channel_id, tags):
-    remove_keys = set()
-    for tag in tags or []:
-        tag = str(tag).strip()
-        if not tag:
-            continue
-        if not tag.startswith("#"):
-            tag = "#" + tag.lstrip("#")
-        remove_keys.add(tag.lower())
-    if not remove_keys:
-        return {"removed": 0, "missing": 0}
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-        if cid not in data["channels"]:
-            return {"removed": 0, "missing": len(remove_keys)}
-        existing = []
-        for tag in data["channels"][cid].get("hashtags", []):
-            tag = str(tag).strip()
-            if tag:
-                existing.append(tag if tag.startswith("#") else "#" + tag.lstrip("#"))
-        before = len(existing)
-        existing = [x for x in existing if x.lower() not in remove_keys]
-        removed = before - len(existing)
-        data["channels"][cid]["hashtags"] = existing
-        _write(data)
-        if removed:
-            _write_backup(data)
-        return {"removed": removed, "missing": max(0, len(remove_keys)-removed)}
-
-
-def record_channel_publish_success(channel_id):
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-        if cid in data.get("channels", {}):
-            data["channels"][cid]["fail_count"] = 0
-        data.setdefault("channel_failures", {})[cid] = 0
-        _write(data)
-        return True
-
-
-def record_channel_publish_failure(channel_id, error="", limit=5):
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-        failures = data.setdefault("channel_failures", {})
-        count = int(failures.get(cid, 0) or 0) + 1
-        failures[cid] = count
-        if cid in data.get("channels", {}):
-            data["channels"][cid]["fail_count"] = count
-            if count >= int(limit):
-                data["channels"][cid]["paused"] = True
-                data["channels"][cid]["auto_paused_reason"] = str(error or "")[:300]
-                data["channels"][cid]["auto_paused_at"] = _now()
-        errors = data.setdefault("last_errors", [])
-        errors.append({"ts": _now(), "context": f"publish channel {cid}", "error": str(error or "")[:500]})
-        data["last_errors"] = errors[-20:]
-        _write(data)
-        return count
-
-
-def create_named_backup(name):
-    name = str(name or "").strip()
-    if not name:
-        name = f"backup_{_now()}"
-    safe = "".join(ch for ch in name if ch.isalnum() or ch in ("_", "-", ".", " ")).strip().replace(" ", "_")
-    if not safe:
-        safe = f"backup_{_now()}"
-    with lock:
-        data = _read()
-        os.makedirs(BACKUP_DIR, exist_ok=True)
-        path = os.path.join(BACKUP_DIR, f"manual_{safe}_{_now()}.json")
-        with open(path, "w", encoding="utf-8") as f:
-            json.dump(_normalize_data(data), f, ensure_ascii=False, indent=2)
-        named = data.setdefault("named_backups", [])
-        named.append({"name": name, "file": path, "ts": _now()})
-        data["named_backups"] = named[-30:]
-        _write(data)
-        return path
-
-
-def get_named_backups():
-    with lock:
-        data = _read()
-    items = data.get("named_backups", [])
-    return items if isinstance(items, list) else []
-
-
-# ===== Published message tracking for channel cleanup =====
-def record_published_message(channel_id, message_id, content_type):
-    """يحفظ ID الرسالة التي نشرها البوت حتى يمكن حذفها لاحقاً حسب النوع."""
-    if not message_id:
-        return False
-    cid = str(channel_id)
-    ctype = str(content_type or "text")
-    if ctype not in {"text", "photo", "video", "album"}:
-        ctype = "photo"
-    with lock:
-        data = _read()
-        box = data.setdefault("published_messages", {}).setdefault(cid, {}).setdefault(ctype, [])
-        mid = int(message_id)
-        if not any(isinstance(x, dict) and int(x.get("id", -1)) == mid for x in box):
-            box.append({"id": mid, "ts": _now()})
-        data["published_messages"][cid][ctype] = box[-1000:]
-        _write(data)
-        return True
-
-
-def record_published_messages(channel_id, message_ids, content_type):
-    count = 0
-    for mid in message_ids or []:
-        if record_published_message(channel_id, mid, content_type):
-            count += 1
-    return count
-
-
-def get_published_message_ids(channel_id, content_type):
-    cid = str(channel_id)
-    ctype = str(content_type or "")
-    with lock:
-        data = _read()
-    entries = data.get("published_messages", {}).get(cid, {}).get(ctype, [])
-    ids = []
-    for item in entries:
-        try:
-            ids.append(int(item.get("id") if isinstance(item, dict) else item))
-        except Exception:
-            pass
-    return ids
-
-
-def clear_published_message_ids(channel_id, content_type, message_ids=None):
-    cid = str(channel_id)
-    ctype = str(content_type or "")
-    remove_set = None
-    if message_ids is not None:
-        remove_set = {int(x) for x in message_ids if str(x).lstrip("-").isdigit()}
-    with lock:
-        data = _read()
-        entries = data.setdefault("published_messages", {}).setdefault(cid, {}).setdefault(ctype, [])
-        if remove_set is None:
-            removed = len(entries)
-            data["published_messages"][cid][ctype] = []
-        else:
-            before = len(entries)
-            data["published_messages"][cid][ctype] = [
-                x for x in entries
-                if int(x.get("id") if isinstance(x, dict) else x) not in remove_set
-            ]
-            removed = before - len(data["published_messages"][cid][ctype])
-        _write(data)
-        return removed
-
-
-def get_ignore_short_posts():
-    with lock:
-        data = _read()
-    return bool(data.get("settings", {}).get("ignore_short_posts", False))
-
-
-def set_ignore_short_posts(enabled):
-    with lock:
-        data = _read()
-        data.setdefault("settings", {})["ignore_short_posts"] = bool(enabled)
-        _write(data)
-        _write_backup(data)
-        return True
-
-
-# ============================================================
-# Link Preview: per-channel disable
-# ============================================================
-
-def get_channel_disable_preview(channel_id, default=False):
-    ch = get_channel(channel_id)
-    if not ch:
-        return bool(default)
-    return bool(ch.get("disable_web_page_preview", default))
-
-
-def set_channel_disable_preview(channel_id, enabled):
-    return update_channel(channel_id, "disable_web_page_preview", bool(enabled))
-
-
-def get_channel_tail_enabled(channel_id):
-    ch = get_channel(str(channel_id))
-    return bool(ch.get("tail_enabled", True)) if ch else True
-
-
-def set_channel_tail_enabled(channel_id, enabled):
-    return update_channel(str(channel_id), "tail_enabled", bool(enabled))
-
-
-def get_channel_tail_min_words(channel_id):
-    ch = get_channel(str(channel_id))
-    return int(ch.get("tail_min_words", 20)) if ch else 20
-
-
-def set_channel_tail_min_words(channel_id, count):
-    return update_channel(str(channel_id), "tail_min_words", max(1, int(count)))
-
-
-def get_channel_tail_position(channel_id):
-    ch = get_channel(str(channel_id))
-    val = ch.get("tail_position", "bottom") if ch else "bottom"
-    return val if val in ("top", "bottom") else "bottom"
-
-
-def set_channel_tail_position(channel_id, position):
-    position = position if position in ("top", "bottom") else "bottom"
-    return update_channel(str(channel_id), "tail_position", position)
-
-
-def get_settings_clipboard():
-    with lock:
-        data = _read()
-    return data.get("settings_clipboard")
-
-
-def set_settings_clipboard(clipboard_data):
-    with lock:
-        data = _read()
-        data["settings_clipboard"] = clipboard_data
-        _write(data)
-
-
-# ============================================================
-# Notification Center Settings
-# ============================================================
-
-NOTIFICATION_TYPES = {
-    "session_stopped": "توقف Session",
-    "ai_key_error": "خطأ في مفتاح AI",
-    "source_stopped": "توقف مصدر",
-    "channel_idle_hour": "قناة لم تنشر منذ ساعة",
-    "backup_failed": "فشل Backup",
-    "db_issue": "مشكلة بقاعدة البيانات",
-}
-
-
-def get_notification_settings():
-    with lock:
-        data = _read()
-    ns = data.get("notification_settings", {})
-    return {k: bool(ns.get(k, True)) for k in NOTIFICATION_TYPES}
-
-
-def set_notification_setting(key, enabled):
-    if key not in NOTIFICATION_TYPES:
-        return False
-    with lock:
-        data = _read()
-        ns = data.setdefault("notification_settings", {})
-        ns[str(key)] = bool(enabled)
-        _write(data)
-    return True
-
-
-def get_notification_last_alert(key):
-    with lock:
-        data = _read()
-    ns = data.get("notification_settings", {})
-    return ns.get("last_alert_ts", {}).get(str(key), 0)
-
-
-def set_notification_last_alert(key, ts=None):
-    if ts is None:
-        ts = _now()
-    with lock:
-        data = _read()
-        ns = data.setdefault("notification_settings", {})
-        alerts = ns.setdefault("last_alert_ts", {})
-        alerts[str(key)] = int(ts)
-        _write(data)
-    return True
-
-
-# ============================================================
-# Multi-Bot Expansion: Sessions
-# ============================================================
-
-def _normalize_session(sid, value):
-    if not isinstance(value, dict):
-        value = {}
-    sid = str(sid)
-    value.setdefault("id", sid)
-    value.setdefault("name", value.get("name") or f"Session {sid.split('_')[-1]}")
-    value.setdefault("api_id", 0)
-    value.setdefault("api_hash", "")
-    value.setdefault("session_string", "")
-    value.setdefault("enabled", True)
-    value.setdefault("created_at", _now())
-    value.setdefault("last_used", None)
-    value.setdefault("usage_count", 0)
-    value.setdefault("error_count", 0)
-    value.setdefault("status", "idle")
-    value.setdefault("channels_using", [])
-    return value
-
-
-def get_all_sessions():
-    with lock:
-        data = _read()
-    return [{"id": k, **v} for k, v in data.get("sessions", {}).items()]
-
-
-def get_session(session_id):
-    sid = str(session_id)
-    with lock:
-        data = _read()
-    raw = data.get("sessions", {}).get(sid)
-    if raw is None:
-        return None
-    return {"id": sid, **raw}
-
-
-def add_session(api_id, api_hash, session_string, name=None):
-    items = get_all_sessions()
-    n = _find_available_number([s.get("name", "") for s in items], "Session")
-    final_name = name or f"Session {n}"
-    sid = f"session_{n}"
-    with lock:
-        data = _read()
-        if sid in data.get("sessions", {}):
-            return False
-        entry = _normalize_session(sid, {
-            "id": sid, "name": final_name,
-            "api_id": int(api_id), "api_hash": str(api_hash),
-            "session_string": str(session_string),
-            "enabled": True, "created_at": _now(),
-        })
-        data.setdefault("sessions", {})[sid] = entry
-        _write(data)
-        _write_backup(data)
-    return True
-
-
-def update_session(session_id, **kwargs):
-    sid = str(session_id)
-    allowed = {"name", "api_id", "api_hash", "session_string", "enabled", "status"}
-    with lock:
-        data = _read()
-        entry = data.get("sessions", {}).get(sid)
-        if not entry:
-            return False
-        for k, v in kwargs.items():
-            if k in allowed and v is not None:
-                entry[k] = v
-        _write(data)
-    return True
-
-
-def delete_session(session_id):
-    sid = str(session_id)
-    with lock:
-        data = _read()
-        entry = data.get("sessions", {}).pop(sid, None)
-        if entry is None:
-            return False
-        item = {"id": f"trash_session_{_now()}", "type": "session", "original_id": sid, "data": entry, "deleted_at": _now()}
-        data.setdefault("trash", []).append(item)
-        _write(data)
-        _write_backup(data)
-    return True
-
-
-def set_session_enabled(session_id, enabled):
-    return update_session(session_id, enabled=bool(enabled))
-
-
-def record_session_usage(session_id):
-    sid = str(session_id)
-    with lock:
-        data = _read()
-        entry = data.get("sessions", {}).get(sid)
-        if not entry:
-            return False
-        entry["last_used"] = _now()
-        entry["usage_count"] = int(entry.get("usage_count", 0)) + 1
-        _write(data)
-    return True
-
-
-def get_session_stats(session_id):
-    s = get_session(session_id)
-    if not s:
-        return {}
-    return {
-        "usage_count": s.get("usage_count", 0),
-        "error_count": s.get("error_count", 0),
-        "last_used": s.get("last_used"),
-        "status": s.get("status", "idle"),
-        "enabled": s.get("enabled", True),
-        "name": s.get("name", ""),
-    }
-
-
-# ============================================================
-# Multi-Bot Expansion: AI Keys
-# ============================================================
-
-def _normalize_ai_key(kid, value):
-    if not isinstance(value, dict):
-        value = {}
-    kid = str(kid)
-    value.setdefault("id", kid)
-    value.setdefault("name", value.get("name") or f"AI {kid.split('_')[-1]}")
-    value.setdefault("provider", "gemini")
-    value.setdefault("api_key", "")
-    value.setdefault("enabled", True)
-    value.setdefault("created_at", _now())
-    value.setdefault("last_used", None)
-    value.setdefault("usage_count", 0)
-    value.setdefault("error_count", 0)
-    value.setdefault("channels_using", [])
-    value.setdefault("models", ["gemini-pro"])
-    return value
-
-
-def get_all_ai_keys():
-    with lock:
-        data = _read()
-    return [{"id": k, **v} for k, v in data.get("ai_keys", {}).items()]
-
-
-def get_ai_key(key_id):
-    kid = str(key_id)
-    with lock:
-        data = _read()
-    raw = data.get("ai_keys", {}).get(kid)
-    return {"id": kid, **raw} if raw else None
-
-
-def add_ai_key(provider, api_key, name=None):
-    items = get_all_ai_keys()
-    n = _find_available_number([k.get("name", "") for k in items], "AI")
-    final_name = name or f"AI {n}"
-    kid = f"ai_{n}"
-    with lock:
-        data = _read()
-        if kid in data.get("ai_keys", {}):
-            return False
-        entry = _normalize_ai_key(kid, {
-            "id": kid, "name": final_name,
-            "provider": str(provider), "api_key": str(api_key),
-            "enabled": True, "created_at": _now(),
-        })
-        data.setdefault("ai_keys", {})[kid] = entry
-        _write(data)
-        _write_backup(data)
-    return True
-
-
-def update_ai_key(key_id, **kwargs):
-    kid = str(key_id)
-    allowed = {"name", "provider", "api_key", "enabled", "models"}
-    with lock:
-        data = _read()
-        entry = data.get("ai_keys", {}).get(kid)
-        if not entry:
-            return False
-        for k, v in kwargs.items():
-            if k in allowed and v is not None:
-                entry[k] = v
-        _write(data)
-    return True
-
-
-def delete_ai_key(key_id):
-    kid = str(key_id)
-    with lock:
-        data = _read()
-        entry = data.get("ai_keys", {}).pop(kid, None)
-        if entry is None:
-            return False
-        item = {"id": f"trash_ai_{_now()}", "type": "ai_key", "original_id": kid, "data": entry, "deleted_at": _now()}
-        data.setdefault("trash", []).append(item)
-        _write(data)
-        _write_backup(data)
-    return True
-
-
-def set_ai_key_enabled(key_id, enabled):
-    return update_ai_key(key_id, enabled=bool(enabled))
-
-
-def record_ai_key_usage(key_id):
-    kid = str(key_id)
-    with lock:
-        data = _read()
-        entry = data.get("ai_keys", {}).get(kid)
-        if not entry:
-            return False
-        entry["last_used"] = _now()
-        entry["usage_count"] = int(entry.get("usage_count", 0)) + 1
-        _write(data)
-    return True
-
-
-def get_ai_key_stats(key_id):
-    k = get_ai_key(key_id)
-    if not k:
-        return {}
-    return {
-        "provider": k.get("provider", ""),
-        "usage_count": k.get("usage_count", 0),
-        "error_count": k.get("error_count", 0),
-        "last_used": k.get("last_used"),
-        "enabled": k.get("enabled", True),
-        "name": k.get("name", ""),
-    }
-
-
-# ============================================================
-# Multi-Bot Expansion: Publishing Bots
-# ============================================================
-
-def _normalize_publishing_bot(bid, value):
-    if not isinstance(value, dict):
-        value = {}
-    bid = str(bid)
-    value.setdefault("id", bid)
-    value.setdefault("name", value.get("name") or f"Bot {bid.split('_')[-1]}")
-    value.setdefault("token", "")
-    value.setdefault("username", "")
-    value.setdefault("enabled", True)
-    value.setdefault("created_at", _now())
-    value.setdefault("last_publish", None)
-    value.setdefault("publish_count", 0)
-    value.setdefault("error_count", 0)
-    value.setdefault("channels_using", [])
-    return value
-
-
-def get_all_publishing_bots():
-    with lock:
-        data = _read()
-    return [{"id": k, **v} for k, v in data.get("publishing_bots", {}).items()]
-
-
-def get_publishing_bot(bot_id):
-    bid = str(bot_id)
-    with lock:
-        data = _read()
-    raw = data.get("publishing_bots", {}).get(bid)
-    return {"id": bid, **raw} if raw else None
-
-
-def add_publishing_bot(token, username="", name=None):
-    items = get_all_publishing_bots()
-    n = _find_available_number([b.get("name", "") for b in items], "Bot")
-    final_name = name or f"Bot {n}"
-    bid = f"bot_{n}"
-    with lock:
-        data = _read()
-        if bid in data.get("publishing_bots", {}):
-            return False
-        entry = _normalize_publishing_bot(bid, {
-            "id": bid, "name": final_name,
-            "token": str(token), "username": str(username),
-            "enabled": True, "created_at": _now(),
-        })
-        data.setdefault("publishing_bots", {})[bid] = entry
-        _write(data)
-        _write_backup(data)
-    return True
-
-
-def update_publishing_bot(bot_id, **kwargs):
-    bid = str(bot_id)
-    allowed = {"name", "token", "username", "enabled"}
-    with lock:
-        data = _read()
-        entry = data.get("publishing_bots", {}).get(bid)
-        if not entry:
-            return False
-        for k, v in kwargs.items():
-            if k in allowed and v is not None:
-                entry[k] = v
-        _write(data)
-    return True
-
-
-def delete_publishing_bot(bot_id):
-    bid = str(bot_id)
-    with lock:
-        data = _read()
-        entry = data.get("publishing_bots", {}).pop(bid, None)
-        if entry is None:
-            return False
-        item = {"id": f"trash_bot_{_now()}", "type": "publishing_bot", "original_id": bid, "data": entry, "deleted_at": _now()}
-        data.setdefault("trash", []).append(item)
-        _write(data)
-        _write_backup(data)
-    return True
-
-
-def set_publishing_bot_enabled(bot_id, enabled):
-    return update_publishing_bot(bot_id, enabled=bool(enabled))
-
-
-def record_bot_publish(bot_id, content_type="text"):
-    bid = str(bot_id)
-    ctype = str(content_type or "text")
-    if ctype not in ("text", "photo", "video", "album"):
-        ctype = "text"
-    with lock:
-        data = _read()
-        entry = data.get("publishing_bots", {}).get(bid)
-        if not entry:
-            return False
-        entry["last_publish"] = _now()
-        entry["publish_count"] = int(entry.get("publish_count", 0)) + 1
-        stats = entry.setdefault("stats", {})
-        stats[ctype] = int(stats.get(ctype, 0)) + 1
-        _write(data)
-    return True
-
-
-# ============================================================
-# Bot-Channel Verification
-# ============================================================
-
-def _normalize_verification(key, value):
-    if not isinstance(value, dict):
-        value = {}
-    value.setdefault("verified", False)
-    value.setdefault("can_post", False)
-    value.setdefault("status", "")
-    value.setdefault("permissions", {})
-    value.setdefault("last_check", 0)
-    value.setdefault("bot_name", "")
-    value.setdefault("channel_name", "")
-    return value
-
-
-def set_bot_channel_verification(bot_id, channel_id, verified, can_post=False, status="", permissions=None, bot_name="", channel_name=""):
-    """تخزين نتيجة التحقق من وجود بوت في قناة."""
-    key = f"{bot_id}|{channel_id}"
-    with lock:
-        data = _read()
-        mapping = data.setdefault("bot_channel_verified", {})
-        entry = _normalize_verification(key, mapping.get(key, {}))
-        entry["verified"] = bool(verified)
-        entry["can_post"] = bool(can_post)
-        entry["status"] = str(status)
-        entry["permissions"] = dict(permissions or {})
-        entry["last_check"] = _now()
-        entry["bot_name"] = str(bot_name)
-        entry["channel_name"] = str(channel_name)
-        mapping[key] = entry
-        _write(data)
-    return True
-
-
-def get_bot_channel_verification(bot_id, channel_id):
-    """إرجاع حالة التحقق المخزنة لبوت في قناة."""
-    key = f"{bot_id}|{channel_id}"
-    with lock:
-        data = _read()
-    entry = data.get("bot_channel_verified", {}).get(key)
-    return _normalize_verification(key, entry)
-
-
-def get_all_bot_channel_verifications():
-    """إرجاع كل حالات التحقق."""
-    with lock:
-        data = _read()
-    return {k: _normalize_verification(k, v) for k, v in data.get("bot_channel_verified", {}).items()}
-
-
-def get_verifications_for_bot(bot_id):
-    """إرجاع كل التحققات لبوت معين."""
-    result = {}
-    prefix = f"{bot_id}|"
-    for k, v in get_all_bot_channel_verifications().items():
-        if k.startswith(prefix):
-            ch_id = k[len(prefix):]
-            result[ch_id] = v
-    return result
-
-
-def get_verifications_for_channel(channel_id):
-    """إرجاع كل التحققات لقناة معينة."""
-    result = {}
-    suffix = f"|{channel_id}"
-    for k, v in get_all_bot_channel_verifications().items():
-        if k.endswith(suffix):
-            bot_id = k[:-len(suffix)]
-            result[bot_id] = v
-    return result
-
-
-# ============================================================
-# Multi-Bot Expansion: Website Sources
-# ============================================================
-
-def _normalize_website(wid, value):
-    if not isinstance(value, dict):
-        value = {}
-    wid = str(wid)
-    value.setdefault("id", wid)
-    value.setdefault("name", value.get("name") or f"Website {wid.split('_')[-1]}")
-    value.setdefault("url", "")
-    value.setdefault("enabled", True)
-    value.setdefault("selector", "body")
-    value.setdefault("interval", 300)
-    value.setdefault("created_at", _now())
-    value.setdefault("last_fetch", None)
-    value.setdefault("error_count", 0)
-    value.setdefault("channels_using", [])
-    return value
-
-
-def get_all_websites():
-    with lock:
-        data = _read()
-    return [{"id": k, **v} for k, v in data.get("websites", {}).items()]
-
-
-def get_website(website_id):
-    wid = str(website_id)
-    with lock:
-        data = _read()
-    raw = data.get("websites", {}).get(wid)
-    return {"id": wid, **raw} if raw else None
-
-
-def add_website(url, name=None, selector="body"):
-    items = get_all_websites()
-    n = _find_available_number([w.get("name", "") for w in items], "Website")
-    final_name = name or f"Website {n}"
-    wid = f"web_{n}"
-    with lock:
-        data = _read()
-        if wid in data.get("websites", {}):
-            return False
-        entry = _normalize_website(wid, {
-            "id": wid, "name": final_name,
-            "url": str(url), "selector": str(selector),
-            "enabled": True, "created_at": _now(),
-        })
-        data.setdefault("websites", {})[wid] = entry
-        _write(data)
-        _write_backup(data)
-    return True
-
-
-def update_website(website_id, **kwargs):
-    wid = str(website_id)
-    allowed = {"name", "url", "enabled", "selector", "interval"}
-    with lock:
-        data = _read()
-        entry = data.get("websites", {}).get(wid)
-        if not entry:
-            return False
-        for k, v in kwargs.items():
-            if k in allowed and v is not None:
-                entry[k] = v
-        _write(data)
-    return True
-
-
-def delete_website(website_id):
-    wid = str(website_id)
-    with lock:
-        data = _read()
-        entry = data.get("websites", {}).pop(wid, None)
-        if entry is None:
-            return False
-        item = {"id": f"trash_web_{_now()}", "type": "website", "original_id": wid, "data": entry, "deleted_at": _now()}
-        data.setdefault("trash", []).append(item)
-        _write(data)
-        _write_backup(data)
-    return True
-
-
-def set_website_enabled(website_id, enabled):
-    return update_website(website_id, enabled=bool(enabled))
-
-
-# ============================================================
-# Multi-Bot Expansion: Trash System
-# ============================================================
-
-def get_trash_items():
-    with lock:
-        data = _read()
-    items = data.get("trash", [])
-    return items if isinstance(items, list) else []
-
-
-def restore_from_trash(trash_id):
-    with lock:
-        data = _read()
-        items = data.get("trash", [])
-        for idx, item in enumerate(items):
-            if item.get("id") == trash_id:
-                orig_type = item.get("type")
-                orig_id = item.get("original_id")
-                orig_data = item.get("data", {})
-                if orig_type == "session":
-                    data.setdefault("sessions", {})[orig_id] = orig_data
-                elif orig_type == "ai_key":
-                    data.setdefault("ai_keys", {})[orig_id] = orig_data
-                elif orig_type == "publishing_bot":
-                    data.setdefault("publishing_bots", {})[orig_id] = orig_data
-                elif orig_type == "website":
-                    data.setdefault("websites", {})[orig_id] = orig_data
-                else:
-                    return False
-                items.pop(idx)
-                data["trash"] = items
-                _write(data)
-                _write_backup(data)
-                return True
-    return False
-
-
-def permanent_delete_from_trash(trash_id):
-    with lock:
-        data = _read()
-        items = data.get("trash", [])
-        for idx, item in enumerate(items):
-            if item.get("id") == trash_id:
-                items.pop(idx)
-                data["trash"] = items
-                _write(data)
-                return True
-    return False
-
-
-def empty_trash():
-    with lock:
-        data = _read()
-        data["trash"] = []
-        _write(data)
-    return True
-
-
-# ============================================================
-# Multi-Bot Expansion: Auto Naming
-# ============================================================
-
-def _find_available_number(names, prefix):
-    used = set()
-    for name in names:
-        if name.startswith(prefix):
-            try:
-                num = int(name[len(prefix):].strip())
-                used.add(num)
-            except ValueError:
-                pass
-    n = 1
-    while n in used:
-        n += 1
-    return n
-
-
-# ============================================================
-# Multi-Bot Expansion: Channel Config Extensions
-# ============================================================
-
-def _normalize_channel_config(cid, value):
-    if not isinstance(value, dict):
-        value = {}
-    cid = str(cid)
-    value.setdefault("title_quote", False)
-    value.setdefault("signature_quote", False)
-    value.setdefault("assigned_sessions", [])
-    value.setdefault("assigned_bots", [])
-    value.setdefault("assigned_ai", [])
-    value.setdefault("websites", [])
-    value.setdefault("rss_sources", [])
-    value.setdefault("prompt", "")
-    value.setdefault("first_comment", "")
-    value.setdefault("schedule", None)
-    return value
-
-
-def get_channel_config(channel_id):
-    cid = str(channel_id)
-    with lock:
-        data = _read()
-    raw = data.get("channel_configs", {}).get(cid)
-    return _normalize_channel_config(cid, raw)
-
-
-def update_channel_config(channel_id, **kwargs):
-    cid = str(channel_id)
-    allowed = {"title_quote", "signature_quote", "assigned_sessions", "assigned_bots", "assigned_ai", "websites", "rss_sources", "prompt", "first_comment", "schedule"}
-    with lock:
-        data = _read()
-        cfg = _normalize_channel_config(cid, data.setdefault("channel_configs", {}).get(cid, {}))
-        for k, v in kwargs.items():
-            if k in allowed and v is not None:
-                cfg[k] = v
-        data["channel_configs"][cid] = cfg
-        _write(data)
-    return True
-
-
-def set_channel_title_quote(channel_id, enabled):
-    return update_channel_config(channel_id, title_quote=bool(enabled))
-
-
-def get_channel_title_quote(channel_id):
-    cfg = get_channel_config(channel_id)
-    return bool(cfg.get("title_quote", False))
-
-
-def set_channel_signature_quote(channel_id, enabled):
-    return update_channel_config(channel_id, signature_quote=bool(enabled))
-
-
-def get_channel_signature_quote(channel_id):
-    cfg = get_channel_config(channel_id)
-    return bool(cfg.get("signature_quote", False))
-
-
-# ============================================================
-# Multi-Bot Expansion: Dependency Check
-# ============================================================
-
-def get_dependencies_for(item_type, item_id):
-    cid = str(item_id)
-    result = []
-    for ch in get_all_channels():
-        ch_id = str(ch.get("id", ""))
-        cfg = get_channel_config(ch_id)
-        if item_type == "session":
-            if cid in [str(x) for x in cfg.get("assigned_sessions", [])]:
-                result.append(ch)
-        elif item_type == "ai_key":
-            if cid in [str(x) for x in cfg.get("assigned_ai", [])]:
-                result.append(ch)
-        elif item_type == "publishing_bot":
-            if cid in [str(x) for x in cfg.get("assigned_bots", [])]:
-                result.append(ch)
-        elif item_type == "website":
-            if cid in [str(x) for x in cfg.get("websites", [])]:
-                result.append(ch)
-    return result
-
-
-# ============================================================
-# Smart Cache System
-# ============================================================
-
-CACHE_TTL = {
-    "bot_in_channel": 300,       # 5 د للعمليات الحساسة
-    "channel_accessible": 600,   # 10 د للتحقق من وجود القناة
-    "bot_token_valid": 3600,     # 1 س لصحة التوكن
-    "session_valid": 600,        # 10 د لصلاحية الجلسة
-    "ui_display": 900,           # 15 د للعرض في الواجهات
-}
-
-_verification_cache = {}
-_cache_lock = Lock()
-
-
-def cache_get(key):
-    """إرجاع قيمة مخبأة إذا كانت ضمن TTL."""
-    with _cache_lock:
-        entry = _verification_cache.get(key)
-        if entry is None:
-            return None
-        if time.time() - entry["ts"] < entry["ttl"]:
-            return entry["data"]
-        del _verification_cache[key]
-        return None
-
-
-def cache_set(key, data, ttl=None):
-    """تخزين قيمة مع TTL."""
-    if ttl is None:
-        ttl = CACHE_TTL.get("ui_display", 900)
-    with _cache_lock:
-        _verification_cache[key] = {"data": data, "ts": time.time(), "ttl": ttl}
-
-
-def cache_invalidate(key):
-    """حذف قيمة من الكاش."""
-    with _cache_lock:
-        _verification_cache.pop(key, None)
-
-
-def cache_invalidate_bot(bot_id):
-    """مسح كل الكاش لبوت معين."""
-    with _cache_lock:
-        to_del = [k for k in _verification_cache if f"|{bot_id}|" in k or f"token_valid|{bot_id}" in k]
-        for k in to_del:
-            del _verification_cache[k]
-
-
-def cache_invalidate_channel(channel_id):
-    """مسح كل الكاش لقناة معينة."""
-    with _cache_lock:
-        to_del = [k for k in _verification_cache if k.endswith(f"|{channel_id}") or k == f"channel|{channel_id}"]
-        for k in to_del:
-            del _verification_cache[k]
-
-
-def cache_clear_expired():
-    """مسح القيم المنتهية."""
-    now = time.time()
-    with _cache_lock:
-        to_del = [k for k, v in _verification_cache.items() if now - v["ts"] >= v["ttl"]]
-        for k in to_del:
-            del _verification_cache[k]
-
-
-# ============================================================
-# Real-Time Verification Functions (Database Layer)
-# ============================================================
-
-VERIFY_TTL_SHORT = 60     # 1 دقيقة
-VERIFY_TTL_NORMAL = 300   # 5 دقائق
-
-
-def get_fresh_bot_verification(bot_id, channel_id):
-    """إرجاع الت��قق من الكاش فقط إذا كان حديثاً (أقل من TTL قصير)."""
-    key = f"verify|{bot_id}|{channel_id}"
-    return cache_get(key)
-
-
-def set_fresh_bot_verification(bot_id, channel_id, result):
-    """تخزين نتيجة تحقق حديثة في الكاش."""
-    key = f"verify|{bot_id}|{channel_id}"
-    cache_set(key, result, ttl=VERIFY_TTL_SHORT)
-
-
-def invalidate_bot_verification(bot_id, channel_id):
-    """مسح التحقق المخبأ لبوت في قناة."""
-    key = f"verify|{bot_id}|{channel_id}"
-    cache_invalidate(key)
-
-
-# ============================================================
-# Bot Manager - المصدر الوحيد لجميع Bot Tokens
-# ============================================================
-
-class BotManager:
-    """يدير جميع بوتات النشر.
-    
-    - أي كود يحتاج توكن بوت يستخدم هذا المدير فقط.
-    - لا يسمح بالوصول المباشر إلى التوكن من أي مكان آخر.
-    - يوفر التوثيق والتخزين والربط مع القنوات.
-    """
-
-    def __init__(self):
-        self._cache = {}
-
-    # ---- المصدر الوحيد للتوكن ----
-    def get_token(self, bot_id):
-        """الطريقة الوحيدة في المشروع بأكمله للحصول على توكن بوت."""
-        b = get_publishing_bot(str(bot_id))
-        if not b:
-            return ""
-        return b.get("token", "")
-
-    def get_bot(self, bot_id):
-        """إرجاع بيانات البوت كاملة (بدون ضمان إخفاء التوكن للاستخدام الداخلي)."""
-        return get_publishing_bot(str(bot_id))
-
-    def get_all_bots(self):
-        """إرجاع جميع البوتات."""
-        return get_all_publishing_bots()
-
-    def add_bot(self, token, username="", name=""):
-        """إضافة بوت جديد."""
-        return add_publishing_bot(token, username=username, name=name)
-
-    def delete_bot(self, bot_id):
-        """حذف بوت ونقل إلى سلة المهملات."""
-        return delete_publishing_bot(str(bot_id))
-
-    def update_bot(self, bot_id, **kwargs):
-        """تحديث بيانات بوت."""
-        return update_publishing_bot(str(bot_id), **kwargs)
-
-    def set_enabled(self, bot_id, enabled):
-        """تشغيل/إيقاف بوت."""
-        return set_publishing_bot_enabled(str(bot_id), enabled)
-
-    def record_publish(self, bot_id, content_type="text"):
-        """تسجيل عملية نشر لبوت."""
-        return record_bot_publish(str(bot_id), content_type)
-
-    def validate_token_format(self, token):
-        """التحقق من صيغة التوكن (بدون اتصال بـ Telegram)."""
-        return bool(token and ":" in token and len(token) > 20)
-
-
-# ============================================================
-# Channel Manager - إدارة موحدة للقنوات
-# ============================================================
-
-class ChannelManager:
-    """يدير جميع القنوات بشكل موحد.
-    
-    - يدمج معلومات القناة (channels) مع إعداداتها (channel_configs).
-    - كل قناة لها Chat ID كمعرف أساسي.
-    - لا يعتمد على الأسماء.
-    """
-
-    def get(self, channel_id):
-        """إرجاع معلومات القناة موحدة مع إعداداتها."""
-        cid = str(channel_id)
-        ch = get_channel(cid)
-        if not ch:
-            return None
-        cfg = get_channel_config(cid)
-        result = dict(ch)
-        result["config"] = cfg
-        return result
-
-    def get_all(self):
-        """إرجاع جميع القنوات مع إعداداتها."""
-        channels = get_all_channels()
-        result = []
-        for ch in channels:
-            cid = str(ch["id"])
-            cfg = get_channel_config(cid)
-            item = dict(ch)
-            item["config"] = cfg
-            result.append(item)
-        return result
-
-    def get_active(self):
-        """إرجاع القنوات غير الموقوفة فقط."""
-        return [ch for ch in self.get_all() if not ch.get("paused")]
-
-    def add(self, channel_id, **meta):
-        """إضافة قناة جديدة."""
-        return add_channel(str(channel_id), **meta)
-
-    def delete(self, channel_id):
-        """حذف قناة."""
-        return delete_channel(str(channel_id))
-
-    def update(self, channel_id, key, value):
-        """تحديث حقل في القناة."""
-        return update_channel(str(channel_id), key, value)
-
-    def get_config(self, channel_id):
-        """إرجاع إعدادات القناة."""
-        return get_channel_config(str(channel_id))
-
-    def update_config(self, channel_id, **kwargs):
-        """تحديث إعدادات القناة."""
-        return update_channel_config(str(channel_id), **kwargs)
-
-    def exists(self, channel_id):
-        """التحقق من وجود القناة في قاعدة البيانات."""
-        return get_channel(str(channel_id)) is not None
-
-
-# ============================================================
-# Bot-Channel Mapper - جدول ربط مستقل
-# ============================================================
-
-class BotChannelMapper:
-    """يدير العلاقة بين البوتات والقنوات.
-    
-    - المصدر الوحيد لمعرفة أي بوت مرتبط بأي قناة.
-    - لا يعتمد على التخزين في الذاكرة.
-    - كل العلاقات مخزنة في قاعدة البيانات.
-    """
-
-    def assign(self, bot_id, channel_id):
-        """ربط بوت بقناة."""
-        bid = str(bot_id)
-        cid = str(channel_id)
-        cfg = get_channel_config(cid)
-        assigned = list(cfg.get("assigned_bots", []))
-        if bid not in [str(x) for x in assigned]:
-            assigned.append(bid)
-            update_channel_config(cid, assigned_bots=assigned)
-            return True
-        return False
-
-    def unassign(self, bot_id, channel_id):
-        """فك ربط بوت من قناة."""
-        bid = str(bot_id)
-        cid = str(channel_id)
-        cfg = get_channel_config(cid)
-        assigned = [str(x) for x in cfg.get("assigned_bots", [])]
-        if bid in assigned:
-            assigned = [x for x in assigned if x != bid]
-            update_channel_config(cid, assigned_bots=assigned)
-            return True
-        return False
-
-    def get_bots_for_channel(self, channel_id):
-        """إرجاع IDs البوتات المرتبطة بقناة."""
-        cfg = get_channel_config(str(channel_id))
-        return [str(x) for x in cfg.get("assigned_bots", [])]
-
-    def get_channels_for_bot(self, bot_id):
-        """إرجاع IDs القنوات التي يستخدمها بوت."""
-        bid = str(bot_id)
-        result = []
-        for ch in get_all_channels():
-            cid = str(ch["id"])
-            cfg = get_channel_config(cid)
-            if bid in [str(x) for x in cfg.get("assigned_bots", [])]:
-                result.append(cid)
-        return result
-
-    def get_assigned_bot_objects(self, channel_id):
-        """إرجاع بيانات البوتات الكاملة المرتبطة بقناة."""
-        bots = []
-        for bid in self.get_bots_for_channel(channel_id):
-            b = get_publishing_bot(bid)
-            if b:
-                bots.append(b)
-        return bots
-
-    def is_assigned(self, bot_id, channel_id):
-        """التحقق من ارتباط بوت بقناة."""
-        return str(bot_id) in self.get_bots_for_channel(channel_id)
-
-    def unassign_all_for_bot(self, bot_id):
-        """فك ربط بوت من جميع القنوات."""
-        bid = str(bot_id)
-        count = 0
-        for cid in self.get_channels_for_bot(bid):
-            if self.unassign(bid, cid):
-                count += 1
-        return count
-
-
-# إنشاء instance عامة للاستخدام في جميع أنحاء المشروع
-bot_manager = BotManager()
-channel_manager = ChannelManager()
-mapper = BotChannelMapper()