Update bot/handlers.py

bot/handlers.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 
 import asyncio
 import os
+import re
 import time
 from dataclasses import dataclass
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Dict, Optional, Tuple, List, Union
 
 from hydrogram import Client, filters
 from hydrogram.types import CallbackQuery, Message
@@ -26,13 +27,13 @@ from bot.ui.callbacks import (
     UP_EDIT,
     UP_GO,
     UP_PRIV,
+    UP_CANCEL,
     NAME_ORIGINAL,
     NAME_CAPTION,
     NAME_CUSTOM,
     BACK,
-    UP_CANCEL,
 )
-from bot.ui.keyboards import auth_menu_keyboard, main_menu_keyboard, profiles_keyboard, upload_confirm_keyboard
+from bot.ui.keyboards import auth_menu_keyboard, filename_keyboard, main_menu_keyboard, profiles_keyboard, upload_confirm_keyboard
 from bot.ui.parse import parse_cb
 from bot.ui.texts import CANCELLED, HELP_TEXT, NEED_AUTH, NOT_ALLOWED, OWNER_ONLY
 from bot.core.progress import SpeedETA, human_bytes, human_eta
@@ -40,17 +41,28 @@ from bot.core.settings import Settings
 from bot.core.uptime import uptime_text
 from bot.youtube.link_parser import parse_telegram_link
 
+ChatRef = Union[int, str]
+
 
 @dataclass
 class PendingUpload:
-    src_msg: Message
-    downloader: Client
+    request_msg: Message              # where user triggered command / sent media
+    src_msg: Message                  # message containing media to download (could be from user session)
+    downloader: Client                # which client downloads src_msg media
     file_name: str
-    caption: str
-    title: str
-    description: str
+    size_hint: int = 0
+
+    # candidates
+    caption_raw: str = ""
+    title_from_filename: str = ""
+    title_from_caption: str = ""
+    desc_from_caption: str = ""
+
+    # chosen final
+    title: str = ""
+    description: str = ""
     privacy: str = "private"
-    title_mode: str = "caption"  # filename | caption | custom
+
     status_msg: Optional[Message] = None
     via_link: bool = False
 
@@ -62,9 +74,9 @@ class EditState:
     privacy: str
 
 
+# In-memory state
 _PENDING_UPLOAD: Dict[int, PendingUpload] = {}
 _AWAIT_EDIT: Dict[int, EditState] = {}
-_AWAIT_AUTH_MODE: Dict[int, str] = {}
 _PENDING_DELETE: Dict[int, str] = {}
 _IN_PROGRESS: Dict[int, bool] = {}
 _UPLOAD_TASK: Dict[int, asyncio.Task] = {}
@@ -75,26 +87,20 @@ def _is_admin_or_owner(uid: int) -> bool:
     return uid in set(Auth.OWNERS) or uid in set(Auth.ADMINS)
 
 
-async def _ensure_allowed_msg(m: Message) -> bool:
-    uid = m.from_user.id if m.from_user else 0
-    if _is_admin_or_owner(uid):
-        return True
-    ok = await is_allowed(uid)
-    if not ok:
-        await safe_reply(m, NOT_ALLOWED)
-    return ok
-
-
-async def _ensure_allowed_cb(uid: int, msg_to_edit: Message) -> bool:
+async def _ensure_allowed_uid(uid: int, reply_target: Message) -> bool:
     """
-    IMPORTANT FIX:
-    CallbackQuery should check q.from_user.id (clicker), NOT q.message.from_user (bot).
+    IMPORTANT:
+    - For Message handlers: uid = m.from_user.id
+    - For CallbackQuery handlers: uid = q.from_user.id (NOT q.message.from_user.id)
     """
     if _is_admin_or_owner(uid):
         return True
+
     ok = await is_allowed(uid)
     if not ok:
-        await safe_edit(msg_to_edit, NOT_ALLOWED, reply_markup=main_menu_keyboard())
+        # try edit first (callbacks), fallback to reply
+        if not await safe_edit(reply_target, NOT_ALLOWED, reply_markup=main_menu_keyboard()):
+            await safe_reply(reply_target, NOT_ALLOWED, reply_markup=main_menu_keyboard())
     return ok
 
 
@@ -106,153 +112,169 @@ def _media_and_filename(m: Message) -> Tuple[Optional[Any], str, int]:
     return None, "", 0
 
 
-def _build_title_desc_from_mode(src: Message, file_name: str, mode: str) -> Tuple[str, str]:
-    cap = (src.caption or "").strip()
-    base = os.path.splitext(file_name)[0].strip()
-    title_from_filename = (base or "Untitled")[: Settings.MAX_TITLE]
+def _caption_text(m: Message) -> str:
+    return (m.caption or "").strip()
 
-    if cap:
-        parts = cap.splitlines()
-        title_from_caption = parts[0].strip()[: Settings.MAX_TITLE]
-        desc_from_caption = "\n".join([p.strip() for p in parts[1:]]).strip()[: Settings.MAX_DESC]
-    else:
-        title_from_caption = ""
-        desc_from_caption = ""
 
-    mode = (mode or "").lower().strip()
+def _filename_title(file_name: str) -> str:
+    base = os.path.splitext(file_name or "")[0].strip()
+    return (base or "Untitled")[: Settings.MAX_TITLE]
 
-    if mode == "filename":
-        # filename as title, keep full caption as description (useful)
-        return title_from_filename, cap[: Settings.MAX_DESC]
-    if mode == "caption":
-        if title_from_caption:
-            return title_from_caption, desc_from_caption
-        return title_from_filename, cap[: Settings.MAX_DESC]
-    # custom fallback
-    return title_from_filename, cap[: Settings.MAX_DESC]
 
+def _caption_title_desc(caption: str) -> Tuple[str, str]:
+    caption = (caption or "").strip()
+    if not caption:
+        return "", ""
+    parts = caption.splitlines()
+    title = parts[0].strip()[: Settings.MAX_TITLE]
+    desc = "\n".join([p.strip() for p in parts[1:]]).strip()[: Settings.MAX_DESC]
+    return title, desc
 
-def _render_preview(p: PendingUpload, size: int) -> str:
-    cap = (p.caption or "").strip()
-    cap_short = (cap[:200] + "…") if len(cap) > 200 else (cap or "—")
 
-    mode = (p.title_mode or "caption").lower()
+def _render_choice_prompt(p: PendingUpload) -> str:
+    cap = p.caption_raw.strip()
+    cap_show = cap if len(cap) <= 900 else (cap[:900] + "…")
+
+    return (
+        "📝 *Choose YouTube title/description source*\n\n"
+        f"📄 *Filename*\n`{p.file_name}`\n"
+        f"→ Title: *{p.title_from_filename or '—'}*\n\n"
+        f"📝 *Caption*\n{cap_show if cap_show else '—'}\n"
+        f"→ Title: *{p.title_from_caption or '—'}*\n\n"
+        "Pick one option below:"
+    )
+
+
+def _render_preview(p: PendingUpload) -> str:
+    cap = p.caption_raw.strip()
+    cap_show = cap if len(cap) <= 400 else (cap[:400] + "…")
+    desc = (p.description or "").strip()
+    desc_show = desc if len(desc) <= 800 else (desc[:800] + "…")
+
+    size_line = human_bytes(p.size_hint) if p.size_hint else "—"
+
     return (
         "📦 *Ready to upload*\n\n"
         f"*File:* `{p.file_name}`\n"
-        f"*Size:* `{human_bytes(size)}`\n"
-        f"*Privacy:* `{p.privacy}`\n"
-        f"*Title source:* `{mode}`\n\n"
-        f"*Caption (preview):*\n`{cap_short}`\n\n"
-        f"*Current Title:*\n`{p.title}`\n\n"
-        f"*Current Description:*\n"
-        f"`{(p.description[:600] + '…') if len(p.description) > 600 else (p.description or '—')}`"
+        f"*Size:* `{size_line}`\n"
+        f"*Privacy:* `{p.privacy}`\n\n"
+        f"*Caption:* {cap_show if cap_show else '—'}\n\n"
+        f"*Title:* {p.title or '—'}\n"
+        f"*Description:* {desc_show if desc_show else '—'}"
     )
 
 
 async def _start_pending_upload(
     *,
     uid: int,
-    request_msg: Message,           # where user asked (DM/group)
-    src: Message,                   # actual media message (maybe from another chat)
+    request_msg: Message,    # where to show preview/progress
+    src_msg: Message,        # where media actually is
     downloader: Client,
     via_link: bool = False,
-    ui_msg: Optional[Message] = None,  # if provided, edit this message instead of replying
 ) -> None:
-    media, file_name, size = _media_and_filename(src)
+    media, file_name, size = _media_and_filename(src_msg)
     if not media:
-        if ui_msg:
-            await safe_edit(ui_msg, "❌ No video/document found in that message.", reply_markup=main_menu_keyboard())
-        else:
-            await safe_reply(request_msg, "❌ No video/document found in that message.")
+        await safe_reply(request_msg, "❌ No video/document found in that message.")
         return
 
-    caption = (src.caption or "").strip()
+    caption = _caption_text(src_msg)
+    t_fn = _filename_title(file_name)
+    t_cap, d_cap = _caption_title_desc(caption)
 
-    # default: prefer caption if present
-    default_mode = "caption" if caption else "filename"
-    title, desc = _build_title_desc_from_mode(src, file_name, default_mode)
+    # Default choice:
+    # - If caption exists, default title+desc from caption
+    # - Else filename title
+    if caption and t_cap:
+        chosen_title = t_cap
+        chosen_desc = d_cap
+    else:
+        chosen_title = t_fn
+        chosen_desc = caption[: Settings.MAX_DESC] if caption else ""
 
     p = PendingUpload(
-        src_msg=src,
+        request_msg=request_msg,
+        src_msg=src_msg,
         downloader=downloader,
         file_name=file_name,
-        caption=caption,
-        title=title,
-        description=desc,
+        size_hint=int(size or 0),
+        caption_raw=caption,
+        title_from_filename=t_fn,
+        title_from_caption=t_cap,
+        desc_from_caption=d_cap,
+        title=chosen_title,
+        description=chosen_desc,
         privacy="private",
-        title_mode=default_mode,
         via_link=via_link,
         status_msg=None,
     )
 
-    txt = _render_preview(p, size)
+    _PENDING_UPLOAD[uid] = p
 
-    # IMPORTANT FIX:
-    # Preview must appear in the request chat (DM/group), not inside the source chat.
-    if ui_msg:
-        p.status_msg = ui_msg
-        _PENDING_UPLOAD[uid] = p
-        await safe_edit(ui_msg, txt, reply_markup=upload_confirm_keyboard(p.privacy, p.title_mode))
-        return
+    # Create ONE status message in the request chat. Everything edits THIS message.
+    if caption:
+        st = await safe_reply(request_msg, _render_choice_prompt(p), reply_markup=filename_keyboard())
+    else:
+        st = await safe_reply(request_msg, _render_preview(p), reply_markup=upload_confirm_keyboard(p.privacy))
 
-    st = await safe_reply(request_msg, txt, reply_markup=upload_confirm_keyboard(p.privacy, p.title_mode))
     p.status_msg = st
     _PENDING_UPLOAD[uid] = p
 
 
+def _as_int(v: Any) -> int:
+    if v is None:
+        return 0
+    if isinstance(v, bool):
+        return int(v)
+    if isinstance(v, (int, float)):
+        return int(v)
+    if isinstance(v, str):
+        try:
+            return int(float(v.strip()))
+        except Exception:
+            return 0
+    if isinstance(v, dict):
+        for k in ("current", "sent", "bytes", "done", "downloaded", "uploaded", "processed", "offset"):
+            if k in v:
+                try:
+                    return int(float(v.get(k) or 0))
+                except Exception:
+                    continue
+        try:
+            return int(float(next(iter(v.values()))))
+        except Exception:
+            return 0
+    return 0
+
+
 async def _run_upload(uid: int) -> Dict[str, Any]:
+    """
+    Runs one upload for uid, editing p.status_msg.
+    Returns: {"ok": True, "url": "..."} or {"ok": False, "err": "..."}
+    """
     if _IN_PROGRESS.get(uid):
         return {"ok": False, "err": "already_running"}
 
     pending = _PENDING_UPLOAD.get(uid)
-    if not pending:
+    if not pending or not pending.status_msg:
         return {"ok": False, "err": "no_pending"}
 
-    st = pending.status_msg
-    if not st:
-        return {"ok": False, "err": "no_status_msg"}
-
     _IN_PROGRESS[uid] = True
+    st = pending.status_msg
     file_path: Optional[str] = None
 
     try:
+        # Ensure default profile exists
         prof = await get_default_profile(uid)
         if not (isinstance(prof, dict) and prof.get("ok") and prof.get("profile_id") and prof.get("access_token")):
             await safe_edit(st, NEED_AUTH, reply_markup=main_menu_keyboard())
-            return {"ok": False, "err": "need_auth"}
+            return {"ok": False, "err": "not_authorized"}
 
         prof_id = str(prof["profile_id"])
         access_token = str(prof["access_token"])
 
         overall_start = time.time()
 
-        def _as_int(v: Any) -> int:
-            if v is None:
-                return 0
-            if isinstance(v, bool):
-                return int(v)
-            if isinstance(v, (int, float)):
-                return int(v)
-            if isinstance(v, str):
-                try:
-                    return int(float(v.strip()))
-                except Exception:
-                    return 0
-            if isinstance(v, dict):
-                for k in ("current", "sent", "bytes", "done", "downloaded", "uploaded", "processed"):
-                    if k in v:
-                        try:
-                            return int(float(v.get(k) or 0))
-                        except Exception:
-                            continue
-                try:
-                    return int(float(next(iter(v.values()))))
-                except Exception:
-                    return 0
-            return 0
-
-        # ---- Download (TG -> temp) ----
+        # ---- Download with live speed ----
         await safe_edit(st, "⬇️ Downloading…")
         dl_speed = SpeedETA()
         dl_last_ui = 0.0
@@ -287,14 +309,15 @@ async def _run_upload(uid: int) -> Dict[str, Any]:
         except Exception:
             file_bytes = 0
 
-        # ---- Upload (temp -> YouTube) ----
+        # ---- Upload with live speed ----
         from bot.youtube.uploader import upload_video
 
+        await safe_edit(st, "⬆️ Uploading…")
         ul_speed = SpeedETA()
         ul_last_ui = 0.0
         ul_start = time.time()
 
-        async def progress_cb(sent: Any, total: Any) -> None:
+        async def ul_progress(sent: Any, total: Any) -> None:
             nonlocal ul_last_ui
             now = time.time()
             if now - ul_last_ui < 0.8:
@@ -321,7 +344,7 @@ async def _run_upload(uid: int) -> Dict[str, Any]:
             title=pending.title,
             description=pending.description,
             privacy=pending.privacy,
-            progress_cb=progress_cb,
+            progress_cb=ul_progress,
         )
 
         if not (isinstance(up, dict) and up.get("ok")):
@@ -330,22 +353,19 @@ async def _run_upload(uid: int) -> Dict[str, Any]:
 
             msg = f"❌ Upload failed: `{err}`"
             if detail:
-                d = str(detail)
-                msg += f"\n`{d[:280]}`"
-                if "uploadLimitExceeded" in d or "quotaExceeded" in d:
-                    msg += "\n\nℹ️ Daily quota limit. Try another profile or retry later."
-
+                msg += f"\n`{str(detail)[:280]}`"
             await safe_edit(st, msg, reply_markup=main_menu_keyboard())
-            return {"ok": False, "err": err, "detail": detail}
+            return {"ok": False, "err": str(err), "detail": detail}
+
+        url = str(up.get("url") or "")
 
-        url = up.get("url") or ""
         await record_upload(uid, prof_id)
 
         ul_dur = max(0.001, time.time() - ul_start)
         total_dur = max(0.001, time.time() - overall_start)
 
-        dl_avg = (human_bytes(file_bytes / dl_dur) + "/s") if file_bytes else "—"
-        ul_avg = (human_bytes(file_bytes / ul_dur) + "/s") if file_bytes else "—"
+        dl_avg = (human_bytes(file_bytes / dl_dur) + "/s") if file_bytes and dl_dur else "—"
+        ul_avg = (human_bytes(file_bytes / ul_dur) + "/s") if file_bytes and ul_dur else "—"
 
         done = "✅ *Uploaded!*"
         if url:
@@ -356,6 +376,7 @@ async def _run_upload(uid: int) -> Dict[str, Any]:
             f"\n*Total:* `{total_dur:.1f}s`"
         )
         await safe_edit(st, done, reply_markup=main_menu_keyboard())
+
         return {"ok": True, "url": url}
 
     except asyncio.CancelledError:
@@ -364,14 +385,13 @@ async def _run_upload(uid: int) -> Dict[str, Any]:
         except Exception:
             pass
         return {"ok": False, "err": "cancelled"}
-
     except Exception as e:
-        await safe_edit(st, f"❌ Error: `{str(e)[:180]}`", reply_markup=main_menu_keyboard())
+        await safe_edit(st, f"❌ Error: `{str(e)[:220]}`", reply_markup=main_menu_keyboard())
         return {"ok": False, "err": "exception", "detail": str(e)}
-
     finally:
         _PENDING_UPLOAD.pop(uid, None)
         _AWAIT_EDIT.pop(uid, None)
+        _PENDING_DELETE.pop(uid, None)
         if file_path:
             try:
                 cleanup_file(file_path)
@@ -381,16 +401,79 @@ async def _run_upload(uid: int) -> Dict[str, Any]:
         _UPLOAD_TASK.pop(uid, None)
 
 
+_BATCH_RANGE_RE = re.compile(r"(.*?)/(\d+)\s*-\s*(\d+)\s*$")
+
+
+def _parse_link_or_range(line: str) -> Tuple[ChatRef, int, int]:
+    """
+    Accepts:
+      https://t.me/c/<chat>/<4012>
+      https://t.me/c/<chat>/<4012-4046>
+      https://t.me/<user>/<10-22>
+    Returns (chat_ref, start, end)
+    """
+    s = (line or "").strip()
+    if not s:
+        raise ValueError("empty")
+
+    # quick detect ".... / 4012-4046"
+    m = _BATCH_RANGE_RE.match(s)
+    if m:
+        base = m.group(1).strip()
+        a = int(m.group(2))
+        b = int(m.group(3))
+        if a <= 0 or b <= 0:
+            raise ValueError("bad_range")
+        if a > b:
+            a, b = b, a
+
+        # rebuild a normal single link to extract chat_ref
+        single = f"{base}/{a}"
+        chat_ref, _mid = parse_telegram_link(single)
+        return chat_ref, a, b
+
+    # normal single link
+    chat_ref, mid = parse_telegram_link(s)
+    return chat_ref, int(mid), int(mid)
+
+
 def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
+    # ---- basic ----
     @app.on_message(filters.command(["start", "help"]))
-    async def start_cmd(_, m: Message) -> None:
-        from bot.ui.texts import START_TEXT
-        await safe_reply(m, START_TEXT, reply_markup=main_menu_keyboard())
+    async def start_help_cmd(_, m: Message) -> None:
+        # always show menu + help text
+        if (m.text or "").strip().lower().startswith("/help"):
+            await safe_reply(m, HELP_TEXT, reply_markup=main_menu_keyboard())
+        else:
+            from bot.ui.texts import START_TEXT
+            await safe_reply(m, START_TEXT, reply_markup=main_menu_keyboard())
+
+    @app.on_message(filters.command("speedtest"))
+    async def speedtest_cmd(_, m: Message) -> None:
+        uid = m.from_user.id if m.from_user else 0
+        if not await _ensure_allowed_uid(uid, m):
+            return
+        from bot.core.speedtest import net_download_test, net_upload_test, public_ip
+        await safe_reply(m, "⏱ Running speed test…")
+        dl = await net_download_test()
+        ul = await net_upload_test()
+        ip = await public_ip()
+
+        dl_bps = float((dl or {}).get("bps", 0) or 0)
+        ul_bps = float((ul or {}).get("bps", 0) or 0)
+
+        msg = (
+            "📶 *Speed Test*\n\n"
+            f"*Uptime:* `{uptime_text()}`\n"
+            f"*Public IP:* `{ip or '—'}`\n\n"
+            f"*Download:* `{human_bytes(dl_bps)}/s`\n"
+            f"*Upload:* `{human_bytes(ul_bps)}/s`"
+        )
+        await safe_reply(m, msg, reply_markup=main_menu_keyboard())
 
     @app.on_message(filters.command("cancel"))
     async def cancel_cmd(_, m: Message) -> None:
         uid = m.from_user.id
-        _AWAIT_AUTH_MODE.pop(uid, None)
         _AWAIT_EDIT.pop(uid, None)
         _PENDING_UPLOAD.pop(uid, None)
         _PENDING_DELETE.pop(uid, None)
@@ -404,8 +487,10 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             btask.cancel()
 
         _IN_PROGRESS.pop(uid, None)
+
         await safe_reply(m, CANCELLED, reply_markup=main_menu_keyboard())
 
+    # ---- admin allowlist ----
     @app.on_message(filters.command("allow"))
     async def allow_cmd(_, m: Message) -> None:
         uid = m.from_user.id
@@ -479,19 +564,19 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             f"Owners: `{len(Auth.OWNERS)}` Admins: `{len(Auth.ADMINS)}`",
         )
 
+    # ---- auth/profile flow ----
     @app.on_message(filters.command("auth"))
     async def auth_cmd(_, m: Message) -> None:
-        if not await _ensure_allowed_msg(m):
-            return
         uid = m.from_user.id
-        _AWAIT_AUTH_MODE[uid] = "oauth"
+        if not await _ensure_allowed_uid(uid, m):
+            return
         await safe_reply(m, "🔐 Add a profile:", reply_markup=auth_menu_keyboard())
 
     @app.on_message(filters.command("profiles"))
     async def profiles_cmd(_, m: Message) -> None:
-        if not await _ensure_allowed_msg(m):
-            return
         uid = m.from_user.id
+        if not await _ensure_allowed_uid(uid, m):
+            return
         data = await list_profiles(uid, only_connected=False)
         if not (isinstance(data, dict) and data.get("ok")):
             await safe_reply(m, "❌ Failed to list profiles.")
@@ -500,23 +585,22 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
         default_id = data.get("default_profile_id") or ""
         await safe_reply(m, "👤 *Profiles*", reply_markup=profiles_keyboard(profiles, default_id))
 
-    # ✅ accept media in any chat (DM/group) - still gated by allowed
-    @app.on_message((filters.video | filters.document))
-    async def media_in_chat(_, m: Message) -> None:
-        if not await _ensure_allowed_msg(m):
-            return
+    # ---- upload from DM media ----
+    @app.on_message(filters.private & (filters.video | filters.document))
+    async def media_in_dm(_, m: Message) -> None:
         uid = m.from_user.id
+        if not await _ensure_allowed_uid(uid, m):
+            return
         if _IN_PROGRESS.get(uid):
             await safe_reply(m, "⏳ Upload already running. Use /cancel to stop.")
             return
+        await _start_pending_upload(uid=uid, request_msg=m, src_msg=m, downloader=app, via_link=False)
 
-        await _start_pending_upload(uid=uid, request_msg=m, src=m, downloader=app, via_link=False, ui_msg=None)
-
-    # ✅ /yt /dl /archive in ANY chat; preview + progress stays in request chat
+    # ---- upload from link (admin/owner) ----
     @app.on_message(filters.command(["yt", "dl", "archive"]))
     async def archive_cmd(_, m: Message) -> None:
         uid = m.from_user.id
-        if not await _ensure_allowed_msg(m):
+        if not await _ensure_allowed_uid(uid, m):
             return
         if not _is_admin_or_owner(uid):
             await safe_reply(m, OWNER_ONLY)
@@ -527,7 +611,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
 
         args = (m.text or "").split(maxsplit=1)
         if len(args) < 2:
-            await safe_reply(m, "Usage: /yt <t.me message link>")
+            await safe_reply(m, "Usage: /archive <t.me message link>")
             return
 
         st = await safe_reply(m, "🔎 Fetching message…")
@@ -537,24 +621,24 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
         try:
             chat_ref, msg_id = parse_telegram_link(args[1].strip())
         except Exception as e:
-            await safe_edit(st, f"Bad link: {e}", reply_markup=main_menu_keyboard())
+            await safe_edit(st, f"Bad link: `{str(e)[:160]}`")
             return
 
         try:
             src = await user_app.get_messages(chat_ref, msg_id)
         except Exception as e:
-            await safe_edit(st, f"❌ Fetch failed: `{str(e)[:180]}`", reply_markup=main_menu_keyboard())
+            await safe_edit(st, f"❌ Fetch failed: `{str(e)[:180]}`")
             return
 
         await safe_edit(st, "✅ Message fetched. Preparing preview…")
-        await _start_pending_upload(uid=uid, request_msg=m, src=src, downloader=user_app, via_link=True, ui_msg=st)
+        await _start_pending_upload(uid=uid, request_msg=m, src_msg=src, downloader=user_app, via_link=True)
 
-    # ✅ batch sequential, stop on first failure by default
+    # ---- batch mode ----
     @app.on_message(filters.command("batch"))
     async def batch_cmd(_, m: Message) -> None:
-        if not await _ensure_allowed_msg(m):
-            return
         uid = m.from_user.id
+        if not await _ensure_allowed_uid(uid, m):
+            return
         if not _is_admin_or_owner(uid):
             await safe_reply(m, OWNER_ONLY)
             return
@@ -562,51 +646,100 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             await safe_reply(m, "❌ Batch mode is not configured (user session missing).")
             return
 
-        args = (m.text or "").split(maxsplit=1)
+        if _BATCH_TASK.get(uid) and not _BATCH_TASK[uid].done():
+            await safe_reply(m, "⏳ A batch is already running. Use /cancel to stop it.")
+            return
+
+        raw = (m.text or "")
+        args = raw.split(maxsplit=1)
         if len(args) < 2:
-            await safe_reply(m, "Send: /batch <t.me message links> (one per line)")
+            await safe_reply(m, "Send: /batch <t.me links> (one per line)\nOptional: /batch --continue <links...>")
             return
 
-        links = [ln.strip() for ln in args[1].splitlines() if ln.strip()]
-        if not links:
+        payload = args[1].strip()
+        continue_on_fail = ("--continue" in payload) or ("-c" in payload)
+        payload = payload.replace("--continue", "").replace("-c", "").strip()
+
+        lines = [ln.strip() for ln in payload.splitlines() if ln.strip()]
+        if not lines:
             await safe_reply(m, "No links found. Put one t.me link per line after /batch")
             return
 
-        if _BATCH_TASK.get(uid) and not _BATCH_TASK[uid].done():
-            await safe_reply(m, "⏳ A batch is already running. Use /cancel to stop it.")
+        # Expand links/ranges
+        items: List[Tuple[ChatRef, int]] = []
+        for ln in lines:
+            try:
+                chat_ref, a, b = _parse_link_or_range(ln)
+            except Exception:
+                await safe_reply(m, f"❌ Bad link/range: `{ln}`")
+                if not continue_on_fail:
+                    return
+                continue
+
+            count = (b - a + 1)
+            if count > Settings.BATCH_MAX_RANGE:
+                await safe_reply(m, f"❌ Range too large ({count}). Max is {Settings.BATCH_MAX_RANGE}.")
+                if not continue_on_fail:
+                    return
+                continue
+
+            for mid in range(a, b + 1):
+                items.append((chat_ref, mid))
+
+        if not items:
+            await safe_reply(m, "No valid items to process.")
             return
 
-        await safe_reply(m, f"🧾 Batch starting: {len(links)} item(s). (Sequential queue)")
+        await safe_reply(m, f"🧾 Batch starting: {len(items)} item(s). Mode: `{'continue' if continue_on_fail else 'stop_on_fail'}`")
 
         async def runner() -> None:
             batch_start = time.time()
-            for i, link in enumerate(links, 1):
-                st = await safe_reply(m, f"🔎 Batch {i}/{len(links)}: fetching…")
+            total = len(items)
+            for i, (chat_ref, msg_id) in enumerate(items, 1):
+                if _IN_PROGRESS.get(uid):
+                    # should not happen (we do sequential), but keep safe
+                    await asyncio.sleep(0.2)
+
+                st = await safe_reply(m, f"🔎 Batch {i}/{total}: fetching message `{msg_id}`…")
                 if not st:
+                    if not continue_on_fail:
+                        break
                     continue
 
-                try:
-                    chat_ref, msg_id = parse_telegram_link(link)
-                except Exception as e:
-                    await safe_edit(st, f"❌ Batch {i}/{len(links)} bad link: {e}", reply_markup=main_menu_keyboard())
-                    return
-
                 try:
                     src = await user_app.get_messages(chat_ref, msg_id)
                 except Exception as e:
-                    await safe_edit(st, f"❌ Batch {i}/{len(links)} fetch failed: `{str(e)[:180]}`", reply_markup=main_menu_keyboard())
-                    return
+                    await safe_edit(st, f"❌ Batch {i}/{total} fetch failed: `{str(e)[:180]}`")
+                    if not continue_on_fail:
+                        break
+                    continue
 
-                await safe_edit(st, f"✅ Batch {i}/{len(links)}: preview…")
-                await _start_pending_upload(uid=uid, request_msg=m, src=src, downloader=user_app, via_link=True, ui_msg=st)
+                media, file_name, size = _media_and_filename(src)
+                if not media:
+                    await safe_edit(st, f"⏭ Batch {i}/{total}: no media in that message. Skipped.")
+                    continue
 
-                await safe_edit(st, f"⏳ Batch {i}/{len(links)}: starting upload…")
-                res = await _run_upload(uid)
+                # Create pending upload targeting THIS chat (m), not source chat
+                await _start_pending_upload(uid=uid, request_msg=m, src_msg=src, downloader=user_app, via_link=True)
 
-                if not (isinstance(res, dict) and res.get("ok")):
-                    # STOP ON FAILURE (your requested behavior)
-                    await safe_reply(m, f"🛑 Batch stopped at item {i}/{len(links)} due to failure.")
-                    return
+                # Force the status message to be this st (so progress edits this line)
+                p = _PENDING_UPLOAD.get(uid)
+                if p:
+                    p.status_msg = st
+                    _PENDING_UPLOAD[uid] = p
+
+                    # Apply the current chosen title/desc and start upload
+                    await safe_edit(st, f"⏳ Batch {i}/{total}: starting upload…")
+                    out = await _run_upload(uid)
+
+                    if not out.get("ok"):
+                        if not continue_on_fail:
+                            await safe_reply(m, f"🛑 Batch stopped (failed at {i}/{total}).")
+                            break
+                else:
+                    await safe_edit(st, f"❌ Batch {i}/{total}: internal error (no pending).")
+                    if not continue_on_fail:
+                        break
 
             batch_dur = max(0.001, time.time() - batch_start)
             await safe_reply(m, f"✅ Batch done in {batch_dur:.1f}s.")
@@ -614,59 +747,52 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
         t = asyncio.create_task(runner())
         _BATCH_TASK[uid] = t
 
+    # ---- callbacks ----
     @app.on_callback_query()
     async def cb_handler(_, q: CallbackQuery) -> None:
         uid = q.from_user.id
         action, value = parse_cb(q.data or "")
 
-        if action == MENU_HELP:
-            await safe_edit(q.message, HELP_TEXT, reply_markup=main_menu_keyboard())
+        # Ignore noop
+        if action == "noop":
             return
 
-        if action == BACK:
-            from bot.ui.texts import START_TEXT
-            await safe_edit(q.message, START_TEXT, reply_markup=main_menu_keyboard())
+        # Menus
+        if action == MENU_HELP:
+            await safe_edit(q.message, HELP_TEXT, reply_markup=main_menu_keyboard())
             return
 
         if action == MENU_SPEED:
-            if not await _ensure_allowed_cb(uid, q.message):
+            if not await _ensure_allowed_uid(uid, q.message):
                 return
-            from bot.core.speedtest import net_download_test, net_upload_test, public_ip, ping_ms
+            from bot.core.speedtest import net_download_test, net_upload_test, public_ip
             await safe_edit(q.message, "⏱ Running speed test…")
-
-            ip = await public_ip()
-            ping = await ping_ms()
-
             dl = await net_download_test()
             ul = await net_upload_test()
+            ip = await public_ip()
 
             dl_bps = float((dl or {}).get("bps", 0) or 0)
             ul_bps = float((ul or {}).get("bps", 0) or 0)
 
-            lines = [
-                "📶 *Speed Test*",
-                f"Uptime: `{uptime_text()}`",
-            ]
-            if ip:
-                lines.append(f"Public IP: `{ip}`")
-            if ping is not None:
-                lines.append(f"Ping(443): `{ping:.0f} ms`")
-
-            lines.append("")
-            lines.append(f"Download: `{human_bytes(dl_bps)}/s`")
-            lines.append(f"Upload: `{human_bytes(ul_bps)}/s`")
-
-            await safe_edit(q.message, "\n".join(lines), reply_markup=main_menu_keyboard())
+            await safe_edit(
+                q.message,
+                "📶 *Speed Test*\n\n"
+                f"*Uptime:* `{uptime_text()}`\n"
+                f"*Public IP:* `{ip or '—'}`\n\n"
+                f"*Download:* `{human_bytes(dl_bps)}/s`\n"
+                f"*Upload:* `{human_bytes(ul_bps)}/s`",
+                reply_markup=main_menu_keyboard(),
+            )
             return
 
         if action == MENU_AUTH:
-            if not await _ensure_allowed_cb(uid, q.message):
+            if not await _ensure_allowed_uid(uid, q.message):
                 return
             await safe_edit(q.message, "🔐 Add a profile:", reply_markup=auth_menu_keyboard())
             return
 
         if action == MENU_PROFILES:
-            if not await _ensure_allowed_cb(uid, q.message):
+            if not await _ensure_allowed_uid(uid, q.message):
                 return
             data = await list_profiles(uid, only_connected=False)
             if not (isinstance(data, dict) and data.get("ok")):
@@ -677,37 +803,48 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             await safe_edit(q.message, "👤 *Profiles*", reply_markup=profiles_keyboard(profiles, default_id))
             return
 
-        # title-source buttons
+        if action == BACK:
+            await safe_edit(q.message, "🏠 Menu", reply_markup=main_menu_keyboard())
+            return
+
+        # Filename/Caption choice
         if action in (NAME_ORIGINAL, NAME_CAPTION, NAME_CUSTOM):
             p = _PENDING_UPLOAD.get(uid)
             if not p:
                 return
 
             if action == NAME_ORIGINAL:
-                p.title_mode = "filename"
-                p.title, p.description = _build_title_desc_from_mode(p.src_msg, p.file_name, "filename")
-            elif action == NAME_CAPTION:
-                p.title_mode = "caption"
-                p.title, p.description = _build_title_desc_from_mode(p.src_msg, p.file_name, "caption")
-            else:
-                # custom -> reuse edit flow
-                p.title_mode = "custom"
-                _AWAIT_EDIT[uid] = EditState(title=p.title, description=p.description, privacy=p.privacy)
+                p.title = (p.title_from_filename or "Untitled")[: Settings.MAX_TITLE]
+                # keep caption as description (if present)
+                p.description = (p.caption_raw or "")[: Settings.MAX_DESC]
+                _PENDING_UPLOAD[uid] = p
+                await safe_edit(q.message, _render_preview(p), reply_markup=upload_confirm_keyboard(p.privacy))
+                return
+
+            if action == NAME_CAPTION:
+                if p.title_from_caption:
+                    p.title = p.title_from_caption[: Settings.MAX_TITLE]
+                    p.description = p.desc_from_caption[: Settings.MAX_DESC]
+                else:
+                    # no caption actually
+                    p.title = (p.title_from_filename or "Untitled")[: Settings.MAX_TITLE]
+                    p.description = ""
                 _PENDING_UPLOAD[uid] = p
+                await safe_edit(q.message, _render_preview(p), reply_markup=upload_confirm_keyboard(p.privacy))
+                return
+
+            if action == NAME_CUSTOM:
+                _AWAIT_EDIT[uid] = EditState(title=p.title, description=p.description, privacy=p.privacy)
                 await safe_edit(
                     q.message,
-                    "✍️ Send new title + description like this:\n\n"
+                    "✍️ Send custom title + description like:\n\n"
                     "Title line\n"
                     "Description lines…\n\n"
                     "(Send only 1 line to change title only)",
                 )
                 return
 
-            _PENDING_UPLOAD[uid] = p
-            media, _, size = _media_and_filename(p.src_msg)
-            await safe_edit(q.message, _render_preview(p, size), reply_markup=upload_confirm_keyboard(p.privacy, p.title_mode))
-            return
-
+        # Upload buttons
         if action == UP_PRIV:
             p = _PENDING_UPLOAD.get(uid)
             if not p:
@@ -715,20 +852,17 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             cycle = {"private": "unlisted", "unlisted": "public", "public": "private"}
             p.privacy = cycle.get(p.privacy, "private")
             _PENDING_UPLOAD[uid] = p
-            _, _, size = _media_and_filename(p.src_msg)
-            await safe_edit(q.message, _render_preview(p, size), reply_markup=upload_confirm_keyboard(p.privacy, p.title_mode))
+            await safe_edit(q.message, _render_preview(p), reply_markup=upload_confirm_keyboard(p.privacy))
             return
 
         if action == UP_EDIT:
             p = _PENDING_UPLOAD.get(uid)
             if not p:
                 return
-            p.title_mode = "custom"
             _AWAIT_EDIT[uid] = EditState(title=p.title, description=p.description, privacy=p.privacy)
-            _PENDING_UPLOAD[uid] = p
             await safe_edit(
                 q.message,
-                "✍️ Send new title + description like this:\n\n"
+                "✍️ Send new title + description like:\n\n"
                 "Title line\n"
                 "Description lines…\n\n"
                 "(Send only 1 line to change title only)",
@@ -737,6 +871,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
 
         if action in (UP_DEL, UP_CANCEL):
             _PENDING_UPLOAD.pop(uid, None)
+            _AWAIT_EDIT.pop(uid, None)
             await safe_edit(q.message, CANCELLED, reply_markup=main_menu_keyboard())
             return
 
@@ -754,9 +889,9 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             _UPLOAD_TASK[uid] = t
             return
 
-        # profile actions
+        # Profile callbacks (from profiles_keyboard)
         if action == "pdel":
-            if not await _ensure_allowed_cb(uid, q.message):
+            if not await _ensure_allowed_uid(uid, q.message):
                 return
             pid = value
             _PENDING_DELETE[uid] = pid
@@ -764,7 +899,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             return
 
         if action == "pdef":
-            if not await _ensure_allowed_cb(uid, q.message):
+            if not await _ensure_allowed_uid(uid, q.message):
                 return
             pid = value
             out = await set_default_profile(uid, pid)
@@ -778,7 +913,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             return
 
         if action == "plog":
-            if not await _ensure_allowed_cb(uid, q.message):
+            if not await _ensure_allowed_uid(uid, q.message):
                 return
             pid = value
             chk = await profile_check_auth(uid, pid)
@@ -792,10 +927,14 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
                 await safe_edit(q.message, "❌ Failed to create login URL.", reply_markup=main_menu_keyboard())
             return
 
+    # ---- edit text handler (private or group, only triggers when waiting) ----
     @app.on_message(filters.text)
-    async def text_in_chat(_, m: Message) -> None:
-        uid = m.from_user.id if m.from_user else 0
+    async def text_anywhere(_, m: Message) -> None:
+        if not m.from_user:
+            return
+        uid = m.from_user.id
 
+        # Confirm delete
         if uid in _PENDING_DELETE:
             if (m.text or "").strip().lower() == "yes":
                 pid = _PENDING_DELETE.pop(uid)
@@ -809,11 +948,13 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
                 await safe_reply(m, "Cancelled.", reply_markup=main_menu_keyboard())
             return
 
+        # Edit title/desc
         if uid in _AWAIT_EDIT:
-            _AWAIT_EDIT.pop(uid, None)
+            st = _AWAIT_EDIT.pop(uid)
             p = _PENDING_UPLOAD.get(uid)
             if not p:
                 return
+
             txt = (m.text or "").strip()
             lines = txt.splitlines()
             if len(lines) == 1:
@@ -821,8 +962,12 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             else:
                 p.title = lines[0].strip()[: Settings.MAX_TITLE]
                 p.description = "\n".join(lines[1:]).strip()[: Settings.MAX_DESC]
-            p.title_mode = "custom"
+
             _PENDING_UPLOAD[uid] = p
-            _, _, size = _media_and_filename(p.src_msg)
-            await safe_reply(m, _render_preview(p, size), reply_markup=upload_confirm_keyboard(p.privacy, p.title_mode))
+
+            # Update preview in the current chat
+            if p.status_msg:
+                await safe_edit(p.status_msg, _render_preview(p), reply_markup=upload_confirm_keyboard(p.privacy))
+            else:
+                await safe_reply(m, _render_preview(p), reply_markup=upload_confirm_keyboard(p.privacy))
             return