newfile.py

# -*- coding: utf-8 -*-
"""
Panel + Login + Destinos/Mensajes + Programación multi-ID + Zona horaria (pytz)

Zona horaria por usuario (default: America/Havana). Conversión a UTC al programar (pytz).
Muestra @usuario/título del destino en progreso (no solo ID).
Requiere plan activo para todo (excepto ADMIN).
"""
import os
import re
import html
import zipfile
import json
import asyncio
import time
from datetime import datetime, date, timedelta
import io
import csv
from telethon.tl import functions, types
from telethon import TelegramClient, events, Button, utils
from telethon.errors import (
    RPCError,
    FloodWaitError,
    SessionPasswordNeededError,
    PhoneCodeInvalidError,
    PhoneCodeExpiredError,
    MessageNotModifiedError,
)

import pytz
from pytz import utc
import html as pyhtml
import shutil
from pathlib import Path
import mimetypes

# =============== CREDENCIALES ===============
API_ID = int(os.environ["API_ID"])
API_HASH = os.environ["API_HASH"]
BOT_TOKEN = os.environ["BOT_TOKEN"]
ADMIN_ID = int(os.environ["ADMIN_ID"])  # si lo usas como int

# =============== RUTAS ===============
BASE = os.path.abspath(os.path.dirname(__file__))
DATA = os.path.join(BASE, "data")
os.makedirs(DATA, exist_ok=True)

USER_SESS = os.path.join(DATA, "user_sessions")
os.makedirs(USER_SESS, exist_ok=True)


def user_state_path(uid: int):
    return os.path.join(DATA, f"{uid}.json")

def user_session_path(uid: int, phone: str) -> str:
    safe = re.sub(r"\D+", "", phone)
    return os.path.join(USER_SESS, f"uid_{uid}_{safe}.session")

# =============== ESTADO POR USUARIO ===============
DEFAULT_USER = {
    "plan_name": None,         # None = sin plan
    "sub_expires": None,       # ISO date (YYYY-MM-DD)
    "timezone": "America/Havana",  # DEFAULT TZ
    "interval_min": 120,
    "hour_start": 8,
    "min_start": 0,
    "hour_end": 20,
    "min_end": 0,
    "program_date": date.today().isoformat(),
    "per_day_limit": 0,
    "used_today": 0,
    "used_date": None,
    "accounts": [],            # [{phone, status, user_id}]
    "destinations": [],        # [peer_id,...]
    "messages": [],            # [{"chat_id":int,"message_id":int}, ...]
    "lang": "es",              # Idioma por defecto
}

def load_user(uid: int):
    p = user_state_path(uid)
    if os.path.exists(p):
        with open(p, "r", encoding="utf-8") as f:
            u = json.load(f)
    else:
        u = dict(DEFAULT_USER)
    # asegurar claves
    for k, v in DEFAULT_USER.items():
        if k not in u:
            u[k] = v
    u = ensure_sets_defaults(u)
    return u

def save_user(uid: int, u: dict):
    with open(user_state_path(uid), "w", encoding="utf-8") as f:
        json.dump(u, f, ensure_ascii=False, indent=2)

def _as_date(exp: str):
    if not exp:
        return None
    try:
        # soporta "YYYY-MM-DD"
        return date.fromisoformat(exp)
    except Exception:
        try:
            # soporta "YYYY-MM-DDTHH:MM:SS"
            return datetime.fromisoformat(exp).date()
        except Exception:
            return None

def remaining_days(u: dict) -> int:
    d = _as_date(u.get("sub_expires"))
    if not d:
        return 0
    return max(0, (d - date.today()).days)

def is_sub_active(uid: int, u: dict) -> bool:
    if str(uid) == str(ADMIN_ID):
        return True
    plan = (u.get("plan_name") or "").strip()
    if not plan:
        return False
    d = _as_date(u.get("sub_expires"))
    return bool(d and d >= date.today())

# === Conjuntos (Sets) ===
# Estructura:
# u["dest_sets"] = {"key": {"name": "Nombre", "ids": [peer_id,...]}}
# u["msg_sets"]  = {"key": {"name": "Nombre", "items": [{"chat_id":..,"message_id":..}, ...]}}

def _slug_key(name: str) -> str:
    s = (name or "").strip()
    s = re.sub(r"\s+", "_", s)
    s = re.sub(r"[^a-zA-Z0-9_\-]", "", s)
    return s.lower()

# Asegurar claves nuevas en usuarios existentes
def ensure_sets_defaults(u: dict) -> dict:
    if "dest_sets" not in u or not isinstance(u["dest_sets"], dict):
        u["dest_sets"] = {}
    if "msg_sets" not in u or not isinstance(u["msg_sets"], dict):
        u["msg_sets"] = {}
    return u

# Convierte nombres -> key y crea si no existe
def create_dest_set(u: dict, name: str) -> tuple[dict, str]:
    ensure_sets_defaults(u)
    key = _slug_key(name)
    if not key:
        raise ValueError("Nombre de conjunto inválido")
    if key in u["dest_sets"]:
        raise ValueError("Ya existe un conjunto de destinos con ese nombre")
    u["dest_sets"][key] = {"name": name.strip(), "ids": []}
    return u, key

def create_msg_set(u: dict, name: str) -> tuple[dict, str]:
    ensure_sets_defaults(u)
    key = _slug_key(name)
    if not key:
        raise ValueError("Nombre de conjunto inválido")
    if key in u["msg_sets"]:
        raise ValueError("Ya existe un conjunto de mensajes con ese nombre")
    u["msg_sets"][key] = {"name": name.strip(), "items": []}
    return u, key

def rename_set(u: dict, kind: str, key: str, new_name: str):
    # kind in {"dest","msg"}
    ensure_sets_defaults(u)
    skey = _slug_key(new_name)
    if not skey:
        raise ValueError("Nombre inválido")
    if kind == "dest":
        if key not in u["dest_sets"]:
            raise KeyError("Conjunto no existe")
        data = u["dest_sets"].pop(key)
        data["name"] = new_name.strip()
        u["dest_sets"][skey] = data
        return skey
    else:
        if key not in u["msg_sets"]:
            raise KeyError("Conjunto no existe")
        data = u["msg_sets"].pop(key)
        data["name"] = new_name.strip()
        u["msg_sets"][skey] = data
        return skey

# =============== BOT ===============
bot = TelegramClient("bot", API_ID, API_HASH).start(bot_token=BOT_TOKEN)

# Flujos pendientes por usuario
PENDING = {}  # uid -> dict

# === PLANES Y REDES (helpers de carga) ===
PLANS_FILE = os.path.join(DATA, "plans.json")
PAY_ADDR_FILE = os.path.join(DATA, "pay_addresses.json")

DEFAULT_PLANS = {
    "basic": {"name": "Básico", "price_usdt": 1.99, "days": 25},
    "standard": {"name": "Estándar", "price_usdt": 3.49, "days": 28},
    "premium": {"name": "Premium", "price_usdt": 4.99, "days": 32},
    "admin": {"name": "Admin", "price_usdt": 0.00, "days": 99999},
}

DEFAULT_PAY_ADDR = {
    "BEP20_ERC20": {"network": "BEP20/ERC20", "address": "0xa5913d80c5dc66d887fe96806d828a7a263ff880"},
    "TRC20": {"network": "TRC-20", "address": "TXJtKUKNuDo4SJQAq3a6tXxppasnpbmwpb"},
    "SPL": {"network": "SPL", "address": "6YWrikq2EvSzG6bYYe5zU5TLYrLeMTW4ARFH6xXvRJxV"},
    "JETTON": {"network": "JETTON", "address": "UQDszvk3alI0at0TuPJiwZw0WKLMhGHGRHU7kR2oDK3IEpyH"},
}

PAGE_SIZE = 10

if not os.path.exists(PLANS_FILE):
    with open(PLANS_FILE, "w", encoding="utf-8") as f:
        json.dump(DEFAULT_PLANS, f, ensure_ascii=False, indent=2)

if not os.path.exists(PAY_ADDR_FILE):
    with open(PAY_ADDR_FILE, "w", encoding="utf-8") as f:
        json.dump(DEFAULT_PAY_ADDR, f, ensure_ascii=False, indent=2)

def load_plans() -> dict:
    try:
        return json.load(open(PLANS_FILE, "r", encoding="utf-8"))
    except Exception:
        return dict(DEFAULT_PLANS)

def load_pays() -> dict:
    try:
        return json.load(open(PAY_ADDR_FILE, "r", encoding="utf-8"))
    except Exception:
        return dict(DEFAULT_PAY_ADDR)

def save_plans(p: dict):
    json.dump(p, open(PLANS_FILE, "w", encoding="utf-8"), ensure_ascii=False, indent=2)

def save_pays(p: dict):
    json.dump(p, open(PAY_ADDR_FILE, "w", encoding="utf-8"), ensure_ascii=False, indent=2)

def ensure_plans_defaults():
    plans = load_plans()
    changed = False
    for k, v in DEFAULT_PLANS.items():
        if k not in plans:
            plans[k] = v
            changed = True
        else:
            for fk in ("name", "price_usdt", "days"):
                if fk not in plans[k]:
                    plans[k][fk] = v[fk]
                    changed = True
    if changed:
        save_plans(plans)

def ensure_pay_defaults():
    pays = load_pays()
    changed = False
    for k, v in DEFAULT_PAY_ADDR.items():
        if k not in pays:
            pays[k] = v
            changed = True
        else:
            for fk in ("network", "address"):
                if fk not in pays[k]:
                    pays[k][fk] = v[fk]
                    changed = True
    if changed:
        save_pays(pays)

ensure_plans_defaults()
ensure_pay_defaults()

# =============== I18N (mínimo viable) ===============
STRINGS = {
    "es": {
        "BTN_BACK": "⬅️ Volver",
        "BTN_HELP": "❓Ayuda",
        "NO_ACCOUNTS_LINKED": "No tienes cuentas vinculadas. Ve a **Administrar cuentas**.",
        "ACC_LABEL": "👤 {phone} (ID {uid})",
        "ERR_INDEX": "Índice inválido.",
        "LBL_DEST": "Dest",
        "LBL_MSG": "Msg",
        "NO_DEST_SETS": "— No hay conjuntos de destinos —",
        "NO_MSG_SETS": "— No hay conjuntos de mensajes —",
        "BTN_CONTINUE": "▶️ Continuar",
        "PROG_PICK_PROFILE": "▶️ Elige **perfil** para programar:",
        "PROG_SELECT_SETS": "Selecciona **conjuntos** a usar para este perfil:",
        "ERR_NEED_SETS": "Debes elegir al menos 1 conjunto de destinos y 1 de mensajes.",
        "ERR_NO_DEST_IN_SETS": "⚠️ Los conjuntos seleccionados no tienen destinos.",
        "ERR_NO_MSG_IN_SETS": "⚠️ Los conjuntos seleccionados no tienen mensajes.",
        "SETS_OK_START": "✅ Conjuntos seleccionados. Pulsa **Iniciar** para programar.",
        "BTN_START": "▶️ Iniciar",

        "PANEL_TITLE": "📊 Panel de Control",
        "SCHEDULE_LINE": "⏰ Horario: {hs}:{ms} a {he}:{me} ({tz})",
        "DATE_LINE": "📅 Fecha programada: {date}",
        "INTERVAL_LINE": "📐 Intervalo: {interval} min",
        "DEST_COUNT_LINE": "🎯 Destinos : {d} (sets: {ds})",
        "MSG_COUNT_LINE": "💬 Mensajes : {m} (sets: {ms})",
        "SUB_LINE": "📅 Suscripción: {days} días rest",
        "PLAN_LINE": "⭐ Plan : {plan}",
        "LANG_LINE": "🌐 Idioma: {lang}",
        "ACCOUNTS_HDR": "📱 Cuentas añadidas:",
        "NO_ACCOUNTS": "—",

        "BTN_DM": "🎯 Destinos & Mensajes",
        "BTN_HD": "⏰ Horario & Días",
        "BTN_ACC": "👥 Administrar cuentas",
        "BTN_PROG": "▶️ Programar",
        "BTN_LANG_MENU": "🌐 Idioma",

        "LANG_MENU_TITLE": "🌐 Idioma\n\nActual: **{code}**\nElige un idioma:",
        "LANG_ES": "Español (ES)",
        "LANG_EN": "English (EN)",
        "LANG_RU": "Русский (RU)",
        "LANG_PT": "Português (PT)",
        "LANG_CHANGED": "✅ Idioma cambiado a **{code}**.",

        "NO_SUB": "🔒 No tienes una suscripción activa.\n\nNecesitas un plan para usar el bot.",
        "SEE_PLANS": "💎 Ver planes",

        "PLANS_WELCOME": "👋 Bienvenido.\n\n💎 Escoge un plan para ver sus detalles:",
        "PLANS_HELP_ALERT": "Toca un plan para ver sus detalles y luego comprar.",

        "SET_MGMT_TITLE": "📂 Gestión de Conjuntos",
        "SET_DEST_LINE": "🎯 Destinos en sets: {d} (sets: {ds})",
        "SET_MSG_LINE": "💬 Mensajes en sets: {m} (sets: {ms})",
        "BTN_SETS_DEST": "🎯 Conjuntos de Destinos",
        "BTN_SETS_MSG": "💬 Conjuntos de Mensajes",

        "DS_TITLE": "🎯 **{name}** (`{key}`)\nDestinos: {n}\n\nOpciones:",
        "BTN_ADD_DEST": "➕ Añadir destinos",
        "BTN_REMOVE_DEST": "➖ Quitar destinos",
        "BTN_RENAME": "📝 Renombrar",
        "BTN_DROP": "🗑 Borrar conjunto",

        "MS_TITLE": "💬 **{name}** (`{key}`)\nMensajes: {n}\n\nOpciones:",
        "BTN_ADD_FROM_SAVED": "➕ Añadir desde mensajes (Guardados)",
        "BTN_ADD_FROM_PEER": "➕ Añadir desde Canal/Grupo",
        "BTN_REMOVE_MSG": "➖ Quitar mensajes",

        "HD_TITLE": "⏰ Gestión de Horarios y Días",
        "TZ_LINE": "🌐 Zona horaria: {tz}",
        "HD_INFO": "Aquí puedes ajustar horarios, fecha, intervalo y zona horaria.",
        "BTN_HSTART": "🕘 Hora ini",
        "BTN_HEND": "🕗 Hora fin",
        "BTN_FPROG": "📅 Fecha prog",
        "BTN_INTERVAL": "📐 Intervalo",
        "BTN_TZ": "🌐 Zona horaria",

        "ACC_MGMT_TITLE": "👥 Administrar cuentas\n\nPerfiles añadidos: {added}/{cap}\n{list}",
        "BTN_ACC_ADD": "➕ Añadir cuenta",
        "BTN_ACC_DEL": "🗑 Eliminar cuenta",

        "TZ_PICK_PROMPT": "🌐 Elige una zona horaria o escribe una personalizada:",
        "BTN_TZ_MANUAL": "✍️ Escribir manualmente",
        "BTN_TZ_PERACC": "🧍‍♂️ Zona por cuenta",
        "TZ_PICK_ACC": "Elige la cuenta para asignar zona horaria:",
        "TZ_PICK_FOR_ACC": "Elige zona horaria para esta cuenta:",
        "TZ_SET_GLOBAL_OK": "✅ Zona horaria global: **{tz}**",
        "TZ_SET_ACC_OK": "✅ Zona por cuenta: **{tz}**",
        "TZ_MANUAL_PROMPT": "Envía una zona IANA (ej: America/Havana).",
        "TZ_ACC_MANUAL_PROMPT": "Envía una zona IANA (ej: America/New_York).",
        "BTN_CREATE_SET": "➕ Crear conjunto",
        "NO_SETS": "— Sin conjuntos —",
        "DEL_PICK_ACCOUNT": "Elige la cuenta a eliminar:",
        "ACC_REMOVED_OK": "✅ Cuenta {phone} eliminada.",
        "INVALID_STATE": "Estado inválido. Vuelve a **Programar**.",
        "DAILY_CAP_LINE": "📈 Límite diario: {cap}\{used}",
    },
    "en": {
        "BTN_BACK": "⬅️ Back",
        "BTN_HELP": "❓Help",
        "NO_ACCOUNTS_LINKED": "You have no linked accounts. Go to **Manage accounts**.",
        "ACC_LABEL": "👤 {phone} (ID {uid})",
        "ERR_INDEX": "Invalid index.",
        "LBL_DEST": "Dest",
        "LBL_MSG": "Msg",
        "NO_DEST_SETS": "— No destination sets —",
        "NO_MSG_SETS": "— No message sets —",
        "BTN_CONTINUE": "▶️ Continue",
        "PROG_PICK_PROFILE": "▶️ Choose a **profile** to schedule:",
        "PROG_SELECT_SETS": "Select **sets** to use for this profile:",
        "ERR_NEED_SETS": "Pick at least 1 destination set and 1 message set.",
        "ERR_NO_DEST_IN_SETS": "⚠️ Selected sets have no destinations.",
        "ERR_NO_MSG_IN_SETS": "⚠️ Selected sets have no messages.",
        "SETS_OK_START": "✅ Sets selected. Press **Start** to schedule.",
        "BTN_START": "▶️ Start",

        "PANEL_TITLE": "📊 Control Panel",
        "SCHEDULE_LINE": "⏰ Time window: {hs}:{ms} to {he}:{me} ({tz})",
        "DATE_LINE": "📅 Scheduled date: {date}",
        "INTERVAL_LINE": "📐 Interval: {interval} min",
        "DEST_COUNT_LINE": "🎯 Destinations in sets: {d} (sets: {ds})",
        "MSG_COUNT_LINE": "💬 Messages in sets: {m} (sets: {ms})",
        "SUB_LINE": "📅 Subscription: {days} days left",
        "PLAN_LINE": "⭐ Active plan: {plan}",
        "LANG_LINE": "🌐 Language: {lang}",
        "ACCOUNTS_HDR": "📱 Linked accounts:",
        "NO_ACCOUNTS": "—",

        "BTN_DM": "🎯 Destinations & Messages",
        "BTN_HD": "⏰ Schedule & Days",
        "BTN_ACC": "👥 Manage accounts",
        "BTN_PROG": "▶️ Schedule",
        "BTN_LANG_MENU": "🌐 Language",

        "LANG_MENU_TITLE": "🌐 Language\n\nCurrent: **{code}**\nChoose a language:",
        "LANG_ES": "Spanish (ES)",
        "LANG_EN": "English (EN)",
        "LANG_RU": "Russian (RU)",
        "LANG_PT": "Portuguese (PT)",
        "LANG_CHANGED": "✅ Language changed to **{code}**.",

        "NO_SUB": "🔒 No active subscription.\n\nYou need a plan to use the bot.",
        "SEE_PLANS": "💎 See plans",

        "PLANS_WELCOME": "👋 Welcome.\n\n💎 Pick a plan to see details:",
        "PLANS_HELP_ALERT": "Tap a plan to view details, then purchase.",

        "SET_MGMT_TITLE": "📂 Set Management",
        "SET_DEST_LINE": "🎯 Destinations in sets: {d} (sets: {ds})",
        "SET_MSG_LINE": "💬 Messages in sets: {m} (sets: {ms})",
        "BTN_SETS_DEST": "🎯 Destination Sets",
        "BTN_SETS_MSG": "💬 Message Sets",

        "DS_TITLE": "🎯 **{name}** (`{key}`)\nDestinations: {n}\n\nOptions:",
        "BTN_ADD_DEST": "➕ Add destinations",
        "BTN_REMOVE_DEST": "➖ Remove destinations",
        "BTN_RENAME": "📝 Rename",
        "BTN_DROP": "🗑 Delete set",

        "MS_TITLE": "💬 **{name}** (`{key}`)\nMessages: {n}\n\nOptions:",
        "BTN_ADD_FROM_SAVED": "➕ Add from Saved Messages",
        "BTN_ADD_FROM_PEER": "➕ Add from Channel/Group",
        "BTN_REMOVE_MSG": "➖ Remove messages",

        "HD_TITLE": "⏰ Schedule & Days",
        "TZ_LINE": "🌐 Timezone: {tz}",
        "HD_INFO": "Adjust hours, date, interval and timezone.",
        "BTN_HSTART": "🕘 Start time",
        "BTN_HEND": "🕗 End time",
        "BTN_FPROG": "📅 Date",
        "BTN_INTERVAL": "📐 Interval",
        "BTN_TZ": "🌐 Timezone",

        "ACC_MGMT_TITLE": "👥 Manage accounts\n\nProfiles added: {added}/{cap}\n{list}",
        "BTN_ACC_ADD": "➕ Add account",
        "BTN_ACC_DEL": "🗑 Remove account",

        "TZ_PICK_PROMPT": "🌐 Choose a timezone or type a custom one:",
        "BTN_TZ_MANUAL": "✍️ Type manually",
        "BTN_TZ_PERACC": "🧍‍♂️ Per-account timezone",
        "TZ_PICK_ACC": "Choose the account to assign a timezone:",
        "TZ_PICK_FOR_ACC": "Choose a timezone for this account:",
        "TZ_SET_GLOBAL_OK": "✅ Global timezone: **{tz}**",
        "TZ_SET_ACC_OK": "✅ Per-account timezone: **{tz}**",
        "TZ_MANUAL_PROMPT": "Send an IANA zone (e.g., America/Havana).",
        "TZ_ACC_MANUAL_PROMPT": "Send an IANA zone (e.g., America/New_York).",
        "BTN_CREATE_SET": "➕ Create set",
        "NO_SETS": "— No sets —",
        "DEL_PICK_ACCOUNT": "Choose the account to remove:",
        "ACC_REMOVED_OK": "✅ Account {phone} removed.",
        "INVALID_STATE": "Invalid state. Go back to **Schedule**.",
        "DAILY_CAP_LINE": "📈 Daily cap: {cap} | Used today: {used} | Remaining: {remaining}"
    },
    "ru": {
        "BTN_BACK": "⬅️ Назад",
        "BTN_HELP": "❓Помощь",
        "NO_ACCOUNTS_LINKED": "Нет привязанных аккаунтов. Откройте **Управление аккаунтами**.",
        "ACC_LABEL": "👤 {phone} (ID {uid})",
        "ERR_INDEX": "Неверный индекс.",
        "LBL_DEST": "Назн",
        "LBL_MSG": "Сооб",
        "NO_DEST_SETS": "— Нет наборов адресатов —",
        "NO_MSG_SETS": "— Нет наборов сообщений —",
        "BTN_CONTINUE": "▶️ Далее",
        "PROG_PICK_PROFILE": "▶️ Выберите **профиль** для расписания:",
        "PROG_SELECT_SETS": "Выберите **наборы** для этого профиля:",
        "ERR_NEED_SETS": "Выберите минимум 1 набор адресатов и 1 набор сообщений.",
        "ERR_NO_DEST_IN_SETS": "⚠️ В выбранных наборах нет адресатов.",
        "ERR_NO_MSG_IN_SETS": "⚠️ В выбранных наборах нет сообщений.",
        "SETS_OK_START": "✅ Наборы выбраны. Нажмите **Старт**.",
        "BTN_START": "▶️ Старт",

        "PANEL_TITLE": "📊 Панель управления",
        "SCHEDULE_LINE": "⏰ Интервал: {hs}:{ms}–{he}:{me} ({tz})",
        "DATE_LINE": "📅 Дата: {date}",
        "INTERVAL_LINE": "📐 Интервал: {interval} мин",
        "DEST_COUNT_LINE": "🎯 Адресатов в наборах: {d} (наборов: {ds})",
        "MSG_COUNT_LINE": "💬 Сообщений в наборах: {m} (наборов: {ms})",
        "SUB_LINE": "📅 Подписка: осталось {days} дн.",
        "PLAN_LINE": "⭐ Тариф: {plan}",
        "LANG_LINE": "🌐 Язык: {lang}",
        "ACCOUNTS_HDR": "📱 Аккаунты:",
        "NO_ACCOUNTS": "—",

        "BTN_DM": "🎯 Адресаты & Сообщения",
        "BTN_HD": "⏰ Время & Дни",
        "BTN_ACC": "👥 Аккаунты",
        "BTN_PROG": "▶️ Расписание",
        "BTN_LANG_MENU": "🌐 Язык",

        "LANG_MENU_TITLE": "🌐 Язык\n\nТекущий: **{code}**\nВыберите язык:",
        "LANG_ES": "Испанский (ES)",
        "LANG_EN": "Английский (EN)",
        "LANG_RU": "Русский (RU)",
        "LANG_PT": "Португальский (PT)",
        "LANG_CHANGED": "✅ Язык изменен на **{code}**.",

        "NO_SUB": "🔒 Нет активной подписки.\n\nНужен тариф.",
        "SEE_PLANS": "💎 Тарифы",

        "PLANS_WELCOME": "👋 Добро пожаловать.\n\n💎 Выберите тариф:",
        "PLANS_HELP_ALERT": "Нажмите на тариф, чтобы посмотреть детали и оплатить.",

        "SET_MGMT_TITLE": "📂 Управление наборами",
        "SET_DEST_LINE": "🎯 Адресатов в наборах: {d} (наборов: {ds})",
        "SET_MSG_LINE": "💬 Сообщений в наборах: {m} (наборов: {ms})",
        "BTN_SETS_DEST": "🎯 Наборы адресатов",
        "BTN_SETS_MSG": "💬 Наборы сообщений",

        "DS_TITLE": "🎯 **{name}** (`{key}`)\nАдресатов: {n}\n\nОпции:",
        "BTN_ADD_DEST": "➕ Добавить адресатов",
        "BTN_REMOVE_DEST": "➖ Удалить адресатов",
        "BTN_RENAME": "📝 Переименовать",
        "BTN_DROP": "🗑 Удалить набор",

        "MS_TITLE": "💬 **{name}** (`{key}`)\nСообщений: {n}\n\nОпции:",
        "BTN_ADD_FROM_SAVED": "➕ Добавить из Сохранённых",
        "BTN_ADD_FROM_PEER": "➕ Добавить из Канала/Группы",
        "BTN_REMOVE_MSG": "➖ Удалить сообщения",

        "HD_TITLE": "⏰ Время & Дни",
        "TZ_LINE": "🌐 Часовой пояс: {tz}",
        "HD_INFO": "Здесь можно настроить время, дату, интервал и часовой пояс.",
        "BTN_HSTART": "🕘 Начало",
        "BTN_HEND": "🕗 Конец",
        "BTN_FPROG": "📅 Дата",
        "BTN_INTERVAL": "📐 Интервал",
        "BTN_TZ": "🌐 Часовой пояс",

        "ACC_MGMT_TITLE": "👥 Аккаунты\n\nДобавлено профилей: {added}/{cap}\n{list}",
        "BTN_ACC_ADD": "➕ Добавить аккаунт",
        "BTN_ACC_DEL": "🗑 Удалить аккаунт",

        "TZ_PICK_PROMPT": "🌐 Выберите часовой пояс или введите свой:",
        "BTN_TZ_MANUAL": "✍️ Ввести вручную",
        "BTN_TZ_PERACC": "🧍‍♂️ Часовой пояс по аккаунту",
        "TZ_PICK_ACC": "Выберите аккаунт для задания часового пояса:",
        "TZ_PICK_FOR_ACC": "Выберите часовой пояс для этого аккаунта:",
        "TZ_SET_GLOBAL_OK": "✅ Глобальный пояс: **{tz}**",
        "TZ_SET_ACC_OK": "✅ По аккаунту: **{tz}**",
        "TZ_MANUAL_PROMPT": "Отправьте зону IANA (напр., America/Havana).",
        "TZ_ACC_MANUAL_PROMPT": "Отправьте зону IANA (напр., America/New_York).",
        "BTN_CREATE_SET": "➕ Создать набор",
        "NO_SETS": "— Нет наборов —",
        "DEL_PICK_ACCOUNT": "Выберите аккаунт для удаления:",
        "ACC_REMOVED_OK": "✅ Аккаунт {phone} удалён.",
        "INVALID_STATE": "Неверное состояние. Вернитесь в **Расписание**.",
        "DAILY_CAP_LINE": "📈 Дневной лимит: {cap} | Использовано: {used} | Осталось: {remaining}",
    },
    "pt": {
        "BTN_BACK": "⬅️ Voltar",
        "BTN_HELP": "❓Ajuda",
        "NO_ACCOUNTS_LINKED": "Você não tem contas vinculadas. Vá em **Gerenciar contas**.",
        "ACC_LABEL": "👤 {phone} (ID {uid})",
        "ERR_INDEX": "Índice inválido.",
        "LBL_DEST": "Dest",
        "LBL_MSG": "Msg",
        "NO_DEST_SETS": "— Não há conjuntos de destinos —",
        "NO_MSG_SETS": "— Não há conjuntos de mensagens —",
        "BTN_CONTINUE": "▶️ Continuar",
        "PROG_PICK_PROFILE": "▶️ Escolha o **perfil** para agendar:",
        "PROG_SELECT_SETS": "Selecione **conjuntos** para este perfil:",
        "ERR_NEED_SETS": "Escolha pelo menos 1 conjunto de destinos e 1 de mensagens.",
        "ERR_NO_DEST_IN_SETS": "⚠️ Conjuntos selecionados sem destinos.",
        "ERR_NO_MSG_IN_SETS": "⚠️ Conjuntos selecionados sem mensagens.",
        "SETS_OK_START": "✅ Conjuntos selecionados. Pressione **Iniciar**.",
        "BTN_START": "▶️ Iniciar",

        "PANEL_TITLE": "📊 Painel de Controle",
        "SCHEDULE_LINE": "⏰ Horário: {hs}:{ms} a {he}:{me} ({tz})",
        "DATE_LINE": "📅 Data agendada: {date}",
        "INTERVAL_LINE": "📐 Intervalo: {interval} min",
        "DEST_COUNT_LINE": "🎯 Destinos nos conjuntos: {d} (sets: {ds})",
        "MSG_COUNT_LINE": "💬 Mensagens nos conjuntos: {m} (sets: {ms})",
        "SUB_LINE": "📅 Assinatura: {days} dias restantes",
        "PLAN_LINE": "⭐ Plano ativo: {plan}",
        "LANG_LINE": "🌐 Idioma: {lang}",
        "ACCOUNTS_HDR": "📱 Contas vinculadas:",
        "NO_ACCOUNTS": "—",

        "BTN_DM": "🎯 Destinos & Mensagens",
        "BTN_HD": "⏰ Horário & Dias",
        "BTN_ACC": "👥 Gerenciar contas",
        "BTN_PROG": "▶️ Agendar",
        "BTN_LANG_MENU": "🌐 Idioma",

        "LANG_MENU_TITLE": "🌐 Idioma\n\nAtual: **{code}**\nEscolha um idioma:",
        "LANG_ES": "Espanhol (ES)",
        "LANG_EN": "Inglês (EN)",
        "LANG_RU": "Russo (RU)",
        "LANG_PT": "Português (PT)",
        "LANG_CHANGED": "✅ Idioma alterado para **{code}**.",

        "NO_SUB": "🔒 Sem assinatura ativa.\n\nVocê precisa de um plano.",
        "SEE_PLANS": "💎 Ver planos",

        "PLANS_WELCOME": "👋 Bem-vindo.\n\n💎 Escolha um plano:",
        "PLANS_HELP_ALERT": "Toque em um plano para ver detalhes e comprar.",

        "SET_MGMT_TITLE": "📂 Gestão de Conjuntos",
        "SET_DEST_LINE": "🎯 Destinos nos conjuntos: {d} (sets: {ds})",
        "SET_MSG_LINE": "💬 Mensagens nos conjuntos: {m} (sets: {ms})",
        "BTN_SETS_DEST": "🎯 Conjuntos de Destinos",
        "BTN_SETS_MSG": "💬 Conjuntos de Mensagens",

        "DS_TITLE": "🎯 **{name}** (`{key}`)\nDestinos: {n}\n\nOpções:",
        "BTN_ADD_DEST": "➕ Adicionar destinos",
        "BTN_REMOVE_DEST": "➖ Remover destinos",
        "BTN_RENAME": "📝 Renomear",
        "BTN_DROP": "🗑 Excluir conjunto",

        "MS_TITLE": "💬 **{name}** (`{key}`)\nMensagens: {n}\n\nOpções:",
        "BTN_ADD_FROM_SAVED": "➕ Adicionar de Mensagens Salvas",
        "BTN_ADD_FROM_PEER": "➕ Adicionar de Canal/Grupo",
        "BTN_REMOVE_MSG": "➖ Remover mensagens",

        "HD_TITLE": "⏰ Horário & Dias",
        "TZ_LINE": "🌐 Fuso horário: {tz}",
        "HD_INFO": "Ajuste horários, data, intervalo e fuso horário.",
        "BTN_HSTART": "🕘 Início",
        "BTN_HEND": "🕗 Fim",
        "BTN_FPROG": "📅 Data",
        "BTN_INTERVAL": "📐 Intervalo",
        "BTN_TZ": "🌐 Fuso horário",

        "ACC_MGMT_TITLE": "👥 Gerenciar contas\n\nPerfis adicionados: {added}/{cap}\n{list}",
        "BTN_ACC_ADD": "➕ Adicionar conta",
        "BTN_ACC_DEL": "🗑 Remover conta",

        "TZ_PICK_PROMPT": "🌐 Escolha um fuso horário ou digite um personalizado:",
        "BTN_TZ_MANUAL": "✍️ Digitar manualmente",
        "BTN_TZ_PERACC": "🧍‍♂️ Fuso por conta",
        "TZ_PICK_ACC": "Escolha a conta para atribuir um fuso:",
        "TZ_PICK_FOR_ACC": "Escolha um fuso para esta conta:",
        "TZ_SET_GLOBAL_OK": "✅ Fuso global: **{tz}**",
        "TZ_SET_ACC_OK": "✅ Fuso por conta: **{tz}**",
        "TZ_MANUAL_PROMPT": "Envie uma zona IANA (ex: America/Havana).",
        "TZ_ACC_MANUAL_PROMPT": "Envie uma zona IANA (ex: America/New_York).",
        "BTN_CREATE_SET": "➕ Criar conjunto",
        "NO_SETS": "— Sem conjuntos —",
        "DEL_PICK_ACCOUNT": "Escolha a conta para remover:",
        "ACC_REMOVED_OK": "✅ Conta {phone} removida.",
        "INVALID_STATE": "Estado inválido. Volte para **Agendar**.",
        "DAILY_CAP_LINE": "📈 Limite diário: {cap}\{used}",
    }
}

# DESPUÉS
def t(u_or_lang, token, **kw):
    base = STRINGS["es"]
    lang = (u_or_lang.get("lang") if isinstance(u_or_lang, dict) else u_or_lang) or "es"
    lang = str(lang).lower()
    s = STRINGS.get(lang, base).get(token, base.get(token, token))
    return s.format(**kw)

# =============== HELPERS ===============
from telethon.tl.functions.messages import GetDialogFiltersRequest

def html_escape(s: str) -> str:
    return html.escape(s or "", quote=True)

def ensure_dir(p: str):
    os.makedirs(p, exist_ok=True)

def media_server_dir_for(target_uid: int, peer_id: int) -> str:
    # Carpeta por usuario y chat en el servidor
    d = os.path.join(MEDIA_DISK_ROOT, str(target_uid), str(peer_id))
    ensure_dir(d)
    return d

def media_server_url_for(target_uid: int, peer_id: int, filename: str) -> str:
    # URL pública del archivo
    # IMPORTANTE: usa "/" siempre, no os.sep, para URLs
    return f"{MEDIA_BASE_URL}/{target_uid}/{peer_id}/{filename}"
    
async def build_folders_index(client):
    """
    Devuelve:
      rows -> [(folder_id, title, count)]
      by_folder -> {folder_id: [Dialog, ...]}
      filters_by_id -> {folder_id: DialogFilter}
    """
    # 1) Filtros (para obtener nombres/títulos)
    res = await client(GetDialogFiltersRequest())
    filters = getattr(res, "filters", res)  # según versión de Telethon
    filters_by_id = {f.id: f for f in (filters or [])}

    # 2) Todos los diálogos del usuario
    dialogs = await client.get_dialogs(limit=None)  # incluye todos (no solo los visibles en pantalla)

    # 3) Agrupar por folder_id
    by_folder = {}
    for d in dialogs:
        fid = getattr(d, "folder_id", None)  # None = sin carpeta; 1 = Archivados; >=2 = carpetas personalizadas
        if fid is None:
            continue
        by_folder.setdefault(fid, []).append(d)

    # 4) Armar filas (id, título, conteo)
    rows = []
    for fid, ds in sorted(by_folder.items()):
        filt = filters_by_id.get(fid)
        title = (filt.title if filt else f"Carpeta {fid}") if hasattr(filt, "title") else f"Carpeta {fid}"
        rows.append((fid, title, len(ds)))

    return rows, by_folder, filters_by_id

async def cq_ack(event, text: str = "", alert: bool = False):
    try:
        # Responder INMEDIATO para que no expire el query
        await event.answer(text, alert=alert, cache_time=0)
    except Exception:
        # Si ya se respondió o expiró, ignoramos el error
        pass

def parse_int(txt):
    try:
        return int(str(txt).strip())
    except Exception:
        return None

def parse_time_hhmm(txt):
    m = re.fullmatch(r"\s*(\d{1,2}):(\d{2})\s*", txt or "")
    if not m:
        return None
    hh, mm = int(m.group(1)), int(m.group(2))
    if 0 <= hh <= 23 and 0 <= mm <= 59:
        return hh, mm
    return None

def parse_date_ymd(txt):
    m = re.fullmatch(r"\s*(\d{4})-(\d{2})-(\d{2})\s*", txt or "")
    if not m:
        return None
    try:
        d = date(int(m.group(1)), int(m.group(2)), int(m.group(3)))
        return d.isoformat()
    except Exception:
        return None

def parse_id_list(text):
    return [int(x) for x in re.findall(r"\d+", text or "")]

def progress_bar(cur, total, width=20):
    if total <= 0:
        return "—"
    ratio = max(0.0, min(1.0, cur / total))
    fill = int(ratio * width)
    return "▰" * fill + "▱" * (width - fill)

def get_tz(tzname: str):
    try:
        return pytz.timezone(tzname)
    except Exception:
        return utc

async def get_first_user_client(uid: int):
    u = load_user(uid)
    for a in (u.get("accounts") or []):
        if a.get("status") != "approved":
            continue
        sess = user_session_path(uid, a["phone"])
        if not os.path.exists(sess):
            continue
        c = TelegramClient(sess, API_ID, API_HASH)
        try:
            await c.connect()
            if await c.is_user_authorized():
                return c, a["phone"]
        except Exception:
            try:
                await c.disconnect()
            except Exception:
                pass
    return None, None

async def ensure_user_client(uid: int):
    client, _ = await get_first_user_client(uid)
    if not client:
        return None, "❌ No hay ninguna cuenta de usuario autorizada. Ve a 👥 Administrar cuentas y añade una."
    try:
        me = await client.get_entity("me")
        _ = utils.get_peer_id(me)
    except Exception:
        await client.disconnect()
        return None, "❌ No pude acceder a tus Mensajes guardados. Repite el login en 👥 Administrar cuentas."
    return client, None

async def normalize_destinations(client, raw_lines, existing_ids):
    ok, skipped, bad, details = [], [], [], []
    seen = set(existing_ids)
    for line in (raw_lines or []):
        src = (line or "").strip()
        if not src:
            continue
        display = src
        if src.startswith("https://t.me/"):
            src = src.split("/")[-1]
        if src.startswith("@"):
            src = src[1:]
        try:
            ent = None
            if src.isdigit():
                try:
                    ent = await client.get_entity(int(src))
                except Exception:
                    ent = None
            if ent is None:
                ent = await client.get_entity(src)
            pid = utils.get_peer_id(ent)
            if pid in seen:
                skipped.append(display)
                details.append(f"↩️ {display} ya estaba")
                continue
            seen.add(pid)
            ok.append(pid)
            details.append(f"✅ {display} verificado")
        except Exception:
            bad.append(display)
            details.append(f"❌ {display} no existe o no hay acceso")
    return ok, skipped, bad, details

async def verify_saved_ids(client, id_list, existing_pairs):
    ok, skipped, bad, details = [], [], [], []
    seen = set(existing_pairs)
    if not id_list:
        return ok, skipped, bad, ["⚠️ No se detectaron IDs."]
    try:
        me = await client.get_entity("me")
        msgs = await client.get_messages(me, ids=id_list)
        me_id = utils.get_peer_id(me)
        for i, mid in enumerate(id_list):
            msg = msgs[i] if i < len(msgs) else None
            pair = (me_id, mid)
            if pair in seen:
                skipped.append(f"{me_id}:{mid}")
                details.append(f"↩️ {me_id}:{mid} ya estaba")
                continue
            if msg is None:
                bad.append(f"{me_id}:{mid}")
                details.append(f"❌ {me_id}:{mid} no existe")
                continue
            ok.append({"chat_id": me_id, "message_id": mid})
            details.append(f"✅ {me_id}:{mid} verificado")
            seen.add(pair)
    except Exception:
        bad.append("error")
        details.append("❌ Error verificando IDs en Guardados")
    return ok, skipped, bad, details

def pretty_entity_name(ent) -> str:
    try:
        if getattr(ent, "username", None):
            return f"@{ent.username}"
        name = (getattr(ent, "title", None) or getattr(ent, "first_name", None) or "").strip()
        if name:
            return name
        return str(utils.get_peer_id(ent))
    except Exception:
        return "—"

async def get_me_peer_id(client):
    me = await client.get_entity("me")
    return utils.get_peer_id(me)

# --- Helper para editar mensajes sin romperse con MessageNotModified ---
async def safe_edit(event, text, buttons=None, parse_mode=None):
    try:
        await event.edit(text, buttons=buttons, parse_mode=parse_mode)
    except MessageNotModifiedError:
        pass
    except Exception:
        await event.respond(text, buttons=buttons, parse_mode=parse_mode)

def flatten_destinations_from_sets(u: dict) -> list[int]:
    ids = set()
    for v in (u.get("dest_sets") or {}).values():
        for pid in (v.get("ids") or []):
            ids.add(int(pid))
    return sorted(ids)

def flatten_messages_from_sets(u: dict) -> list[tuple[int,int]]:
    seen = set(); out = []
    for v in (u.get("msg_sets") or {}).values():
        for it in (v.get("items") or []):
            pair = (int(it["chat_id"]), int(it["message_id"]))
            if pair not in seen:
                seen.add(pair); out.append(pair)
    return out

async def resolve_names_map(client, peer_ids: list[int]) -> dict[int,str]:
    names = {}
    for pid in peer_ids:
        try:
            ent = await client.get_entity(pid)
            names[pid] = pretty_entity_name(ent)
        except Exception:
            names[pid] = str(pid)
    return names

async def send_csv(admin_id: int, filename: str, headers: list[str], rows: list[list]):
    buf = io.StringIO()
    writer = csv.writer(buf)
    writer.writerow(headers)
    writer.writerows(rows)
    bio = io.BytesIO(buf.getvalue().encode("utf-8-sig"))
    bio.name = filename
    await bot.send_file(admin_id, bio, caption=filename, force_document=True)

# ---------- HELPERS DE EDICIÓN Y CSV ----------
async def render_one_message_to_server(client, m, target_uid, peer_id):
    who = "me" if getattr(m, "out", False) else "them"
    text = html_escape(getattr(m, "message", "") or "")

    part = [f'<div class="msg {who}"><div class="bubble"><div class="content">{text}']

    media_saved_path = None
    media_url        = None
    media_mime       = None

    # prefijo único; Telethon añadirá la extensión real
    file_prefix = os.path.join(media_server_dir_for(target_uid, peer_id), f"{m.id}_{int(getattr(m, 'date', datetime.utcnow()).timestamp())}")

    if getattr(m, "photo", None):
        media_saved_path = await client.download_media(m, file=file_prefix)
        media_mime = "image/jpeg"  # típicamente fotos
    elif getattr(m, "document", None):
        mime = getattr(m.document, "mime_type", "") or ""
        if mime.startswith(("image/", "video/", "audio/")) or mime in ("image/webp", "video/mp4"):
            media_saved_path = await client.download_media(m, file=file_prefix)
            media_mime = mime

    # Si hubo media, crea su URL pública y botones
    if media_saved_path:
        filename = os.path.basename(media_saved_path)
        media_url = media_server_url_for(target_uid, peer_id, filename)
        guess = media_mime or (mimetypes.guess_type(filename)[0] or "")

        if guess.startswith("image/"):
            part.append(f'<img src="{media_url}" alt="img_{m.id}">')
        elif guess.startswith("video/"):
            part.append(f'<video controls playsinline src="{media_url}"></video>')
        elif guess.startswith("audio/"):
            part.append(f'<audio controls src="{media_url}"></audio>')
        else:
            # archivo genérico descargable
            pass

        # Botón de descarga SIN salir de la página (usa JS fetch+blob)
        part.append(f'''
        <div style="margin-top:6px">
          <button class="dlbtn" onclick="dl('{media_url}','{html_escape(filename)}')">⬇️ Descargar</button>
          <a class="openbtn" href="{media_url}" target="_blank" rel="noopener">Abrir</a>
        </div>
        ''')

    dt = getattr(m, "date", None)
    ts = dt.strftime("%Y-%m-%d %H:%M") if dt else ""
    part.append(f'</div><div class="meta">{ts}</div></div></div>')
    return "".join(part)
    
async def send_csv(uid: int, filename: str, headers: list[str], rows: list[list]):
    import csv, io
    buf = io.StringIO()
    w = csv.writer(buf)
    w.writerow(headers)
    w.writerows(rows)
    data = buf.getvalue().encode("utf-8")
    buf.close()
    path = os.path.join(DATA, filename)
    with open(path, "wb") as f:
        f.write(data)
    try:
        await bot.send_file(uid, path, caption=filename)
    except Exception:
        # fallback como documento
        await bot.send_file(uid, path)
            
def as_plain_text(x):
    # Convierte DialogFilter.title a texto legible
    if x is None:
        return ""
    t = getattr(x, "text", None)
    if isinstance(t, str):
        return t
    if isinstance(x, str):
        return x
    return str(x)
    
import os, html, mimetypes
from datetime import datetime
import pytz
from telethon import utils

def _esc(s: str) -> str:
    return html.escape(s or "", quote=True)

def _pretty_name_from_ent(ent) -> str:
    try:
        if getattr(ent, "username", None):
            return f"@{ent.username}"
        name = (getattr(ent, "title", None) or getattr(ent, "first_name", None) or "").strip()
        if name:
            return name
        return str(utils.get_peer_id(ent))
    except Exception:
        return "—"

async def export_chat_html(
    client,
    peer,                 # entidad o peer_id/@usuario/link t.me
    out_dir: str,         # carpeta de salida (p.ej. os.path.join(DATA, "exports", f"{uid}_{peer_id}"))
    tzname: str = "America/Havana",
    limit: int = 3000
) -> str:
    """
    Exporta un chat a un HTML (burbujas) y guarda la multimedia en out_dir/media.
    Devuelve la ruta a out_dir/index.html
    """
    os.makedirs(out_dir, exist_ok=True)
    media_dir = os.path.join(out_dir, "media")
    os.makedirs(media_dir, exist_ok=True)

    # Entidad / IDs
    ent = await client.get_entity(peer)
    peer_id = utils.get_peer_id(ent)

    # Quién soy (para alinear derecha los "míos")
    try:
        me = await client.get_me()
        me_id = me.id
    except Exception:
        me_id = None

    # Zona horaria
    try:
        tz = pytz.timezone(tzname)
    except Exception:
        tz = pytz.timezone("America/Havana")

    # Leer mensajes (nuevo->viejo) y ordenar cronológico
    messages = []
    async for m in client.iter_messages(ent, limit=limit):
        messages.append(m)
    messages.reverse()

    # Cache de nombres
    name_cache = {}
    async def name_of(uid):
        if uid is None:
            return _pretty_name_from_ent(ent)
        if uid in name_cache:
            return name_cache[uid]
        try:
            uent = await client.get_entity(uid)
            nm = _pretty_name_from_ent(uent)
        except Exception:
            nm = str(uid)
        name_cache[uid] = nm
        return nm

    # Construcción del HTML (UNA sola salida: index.html)
    html_path = os.path.join(out_dir, "index.html")
    html_parts = []
    html_parts.append("""<!doctype html>
<meta charset="utf-8">
<title>Chat export</title>
<style>
  body{font-family:system-ui,-apple-system,Segoe UI,Roboto,Arial,sans-serif;background:#0f1214;margin:0;padding:16px}
  .chat{max-width:920px;margin:0 auto;display:flex;flex-direction:column;gap:10px}
  .msg{display:flex;flex-direction:column;gap:6px;max-width:85%}
  .msg.them{align-self:flex-start}
  .msg.me{align-self:flex-end}
  .meta{opacity:.75;font-size:12px;display:flex;gap:8px}
  .them .meta .name{color:#a5b4fc}
  .me   .meta .name{color:#86efac}
  .bubble{padding:10px 12px;border-radius:16px;line-height:1.35;word-wrap:break-word;overflow:hidden;
          box-shadow:0 6px 16px rgba(0,0,0,.25);border:1px solid rgba(255,255,255,0.08)}
  .them .bubble{background:linear-gradient(180deg, rgba(99,102,241,0.25), rgba(99,102,241,0.12));
                border-top-left-radius:6px}
  .me .bubble{background:linear-gradient(180deg, rgba(34,197,94,0.25), rgba(34,197,94,0.12));
              border-top-right-radius:6px}
  .content{white-space:pre-wrap;word-wrap:break-word}
  .content img,.content video{max-width:320px;border-radius:12px;display:block;margin-top:6px}
  .content audio{display:block;margin-top:6px}
  a.file{display:inline-block;margin-top:6px;padding:6px 10px;background:rgba(148,163,184,0.15);color:#e6edf3;text-decoration:none;border-radius:10px}
</style>
<body><div class="chat">
""")

    for m in messages:
        who = "me" if (getattr(m, "out", False) or (me_id and getattr(m, "sender_id", None) == me_id)) else "them"
        sid = getattr(m, "sender_id", None)
        who_name = "Tú" if who == "me" else await name_of(sid)
        text = _esc(getattr(m, "message", "") or "")

        # hora
        dt = getattr(m, "date", None)
        if dt is not None:
            if dt.tzinfo is None:
                dt = pytz.utc.localize(dt)
            time_html = dt.astimezone(tz).strftime("%Y-%m-%d %H:%M")
        else:
            time_html = ""

        # media -> SOLO a out_dir/media (rutas relativas)
        media_block = ""
        try:
            if getattr(m, "media", None):
                # Deja que Telethon ponga extensión; usa prefijo con id
                target_path = os.path.join(media_dir, f"{m.id}")
                saved_path = await client.download_media(m, file=target_path)
                if saved_path:
                    rel = os.path.relpath(saved_path, out_dir).replace("\\", "/")
                    mime = mimetypes.guess_type(saved_path)[0] or ""
                    if mime.startswith("image/"):
                        media_block = f'<img src="{_esc(rel)}" alt="img_{m.id}">'
                    elif mime.startswith("video/"):
                        media_block = f'<video controls playsinline src="{_esc(rel)}"></video>'
                    elif mime.startswith("audio/"):
                        media_block = f'<audio controls src="{_esc(rel)}"></audio>'
                    else:
                        media_block = f'<a class="file" href="{_esc(rel)}">Descargar archivo</a>'
        except Exception:
            # ignora errores de descarga para no romper el HTML
            pass

        content_html = text if text else ""
        if media_block:
            content_html = (text + "<br>" + media_block) if text else media_block
        if not content_html:
            content_html = "(sin contenido)"

        html_parts.append(
            f'''
            <div class="msg {who}">
              <div class="meta">
                <span class="name">{_esc(who_name)}</span>
                <span class="time">{_esc(time_html)}</span>
              </div>
              <div class="bubble">
                <div class="content">{content_html}</div>
              </div>
            </div>
            '''
        )

    html_parts.append("</div></body>")
    with open(html_path, "w", encoding="utf-8") as f:
        f.write("".join(html_parts))

    return html_path

def _zip_dir(src_dir: str, out_zip: str):
    # Crea ZIP del directorio (incluye HTML + media)
    # out_zip SIN extensión
    base = os.path.abspath(src_dir)
    zip_base = os.path.abspath(out_zip)
    if os.path.exists(zip_base + ".zip"):
        os.remove(zip_base + ".zip")
    shutil.make_archive(zip_base, "zip", base)
    return zip_base + ".zip"

PAGE_SIZE = 10           # 10 chats por página
EXPORT_MAX_MSGS = 300000   # tope de mensajes a exportar por chat (ajústalo)
EXPORT_DIR = os.path.join(DATA, "exports")
os.makedirs(EXPORT_DIR, exist_ok=True)

def safe_filename(name: str) -> str:
    name = re.sub(r"[^\w\-. ]+", "_", name or "")
    return name[:80] or "file"

def html_escape(s: str) -> str:
    try:
        return html.escape(s or "")
    except Exception:
        return str(s)

def _media_tag(relpath: str, mime: str | None):
    m = (mime or "").lower()
    if m.startswith("image/"):
        return f'<div class="m"><img src="{relpath}" /></div>'
    if m.startswith("video/"):
        return f'<div class="m"><video controls src="{relpath}"></video></div>'
    if m.startswith("audio/"):
        return f'<div class="m"><audio controls src="{relpath}"></audio></div>'
    # documento por defecto
    return f'<div class="m"><a download href="{relpath}">Descargar adjunto</a></div>'

async def export_chat_to_html(client, peer, out_root: str, max_msgs: int = EXPORT_MAX_MSGS) -> str:
    """
    Crea una carpeta con index.html + /media y devuelve la ruta del ZIP
    """
    ent = await client.get_entity(peer)
    pid = utils.get_peer_id(ent)
    title = (getattr(ent, "title", None) or getattr(ent, "first_name", None) or getattr(ent, "username", None) or str(pid))
    folder = os.path.join(out_root, f"peer_{pid}_{safe_filename(str(title))}")
    media_dir = os.path.join(folder, "media")
    os.makedirs(media_dir, exist_ok=True)

    # Recolectamos mensajes (del más reciente al más antiguo), luego invertimos
    msgs = []
    async for m in client.iter_messages(ent, limit=max_msgs):
        msgs.append(m)
    msgs.reverse()

    # Construimos HTML
    head = f"""<!doctype html>
<html lang="es"><head><meta charset="utf-8">
<title>Chat: {html_escape(str(title))}</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<style>
body{{font-family:system-ui,-apple-system,Segoe UI,Roboto,Arial,sans-serif;background:#111;color:#eee;margin:0;}}
.wrap{{max-width:900px;margin:0 auto;padding:20px;}}
.h{{font-size:20px;margin:0 0 12px;}}
.msg{{background:#1c1c1c;border-radius:8px;padding:10px 12px;margin:8px 0;}}
.msg.out{{background:#18222e}}
.meta{{opacity:.7;font-size:12px;margin-bottom:6px}}
.t{{white-space:pre-wrap;word-wrap:break-word;}}
.m img{{max-width:100%;height:auto;border-radius:6px}}
.m video,.m audio{{max-width:100%}}
hr{{border:0;border-top:1px solid #333;margin:18px 0}}
.small{{font-size:12px;opacity:.7}}
</style></head><body><div class="wrap">
<h1 class="h">Chat: {html_escape(str(title))}</h1>
<p class="small">Total mensajes exportados: {len(msgs)} — Generado por tu bot</p><hr>
"""
    body_parts = []

    for m in msgs:
        # meta
        dt = (m.date or datetime.utcnow()).strftime("%Y-%m-%d %H:%M:%S")
        author = None
        if getattr(m, "sender", None):
            a = m.sender
            author = getattr(a, "first_name", None) or getattr(a, "title", None) or getattr(a, "username", None)
        if not author and getattr(m, "from_id", None):
            author = str(m.from_id)
        author = author or "—"

        classes = "msg out" if m.out else "msg"
        meta = f'<div class="meta">{html_escape(author)} — {html_escape(dt)}</div>'

        parts = []
        # texto
        if m.message:
            parts.append(f'<div class="t">{html_escape(m.message)}</div>')

        # media
        if m.media:
            try:
                # descarga a /media
                path = await client.download_media(m, file=media_dir)
                if path:
                    rel = os.path.relpath(path, folder).replace("\\", "/")
                    mime = getattr(getattr(m, "document", None), "mime_type", None) \
                           or getattr(getattr(m, "media", None), "mime_type", None)
                    parts.append(_media_tag(rel, mime))
            except Exception:
                # si falla descarga, al menos deja un placeholder
                parts.append('<div class="m">[Adjunto no descargado]</div>')

        if not parts:
            # mensaje sin texto ni media (p. ej. servicio)
            parts.append('<div class="t">—</div>')

        body_parts.append(f'<div class="{classes}">{meta}' + "".join(parts) + '</div>')

    tail = "</div></body></html>"
    html_text = head + "\n".join(body_parts) + tail

    # Guardar HTML
    index_path = os.path.join(folder, "index.html")
    with open(index_path, "w", encoding="utf-8") as f:
        f.write(html_text)

    # Comprimir a ZIP
    zip_path = os.path.join(out_root, f"chat_{pid}_{safe_filename(str(title))}.zip")
    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as z:
        # añadir index
        z.write(index_path, arcname=os.path.join(os.path.basename(folder), "index.html"))
        # añadir media
        if os.path.isdir(media_dir):
            for root, _, files in os.walk(media_dir):
                for name in files:
                    p = os.path.join(root, name)
                    arc = os.path.join(os.path.basename(folder), "media", os.path.relpath(p, media_dir))
                    z.write(p, arcname=arc)
    return zip_path
# ======== Helpers de suscripción/bloqueo ========
def is_user_blocked(u: dict) -> bool:
    blk = u.get("blocked") or {}
    return bool(blk.get("active"))

def get_block_info(u: dict) -> str:
    blk = u.get("blocked") or {}
    reason = blk.get("reason") or "Sin motivo"
    since = blk.get("since") or "—"
    return f"🚫 Usuario bloqueado desde {since}. Motivo: {reason}"

def set_user_block(uid: int, active: bool, reason: str = None, by_admin: int = None):
    u = load_user(uid)
    u["blocked"] = u.get("blocked") or {}
    u["blocked"]["active"] = bool(active)
    u["blocked"]["reason"] = (reason or "").strip() if active else None
    u["blocked"]["by"] = str(by_admin) if active and by_admin is not None else None
    u["blocked"]["since"] = date.today().isoformat() if active else None
    save_user(uid, u)
    return u

def _resolve_plan_key(plan_txt: str) -> str | None:
    p = (plan_txt or "").strip().lower()
    aliases = {
        "basic": {"basic", "básico", "basico"},
        "standard": {"standard", "estándar", "estandar"},
        "premium": {"premium"},
        "admin": {"admin"},
    }
    for key, names in aliases.items():
        if p in names:
            return key
    return None

# =============== DECORADOR DE PLAN ===============
def plan_guard(cb):
    async def wrapper(event, *args, **kwargs):
        uid = event.sender_id
        u = load_user(uid)

        # 1) Bloqueo primero
        if is_user_blocked(u):
            try:
                await event.edit(get_block_info(u))
            except Exception:
                await event.respond(get_block_info(u))
            return

        # 2) Suscripción activa
        if not is_sub_active(uid, u):
            text = t(u, "NO_SUB")
            kb = [[Button.inline(t(u, "SEE_PLANS"), b"plans_menu_compact")]]
            try:
                await event.edit(text, buttons=kb)
            except Exception:
                await event.respond(text, buttons=kb)
            return

        return await cb(event, *args, **kwargs)

    return wrapper

# === PLAN POLICY ===
def plan_policy(plan_name: str) -> dict:
    """
    Perfiles, rango de fechas, regla de horas, intervalo mínimo y *tope diario*.
    LÍMITES NUEVOS:
      - Básico   -> 500 / día
      - Estándar -> 2000 / día
      - Premium  -> 6000 / día
    """
    p = (plan_name or "").strip().lower()
    if p in ("básico", "basico"):
        return {
            "profiles": 1,
            "date_days": 1,
            "hours_rule": "even_8_20",
            "interval_min": 120,
            "daily_messages_cap": 500,      # <-- actualizado
        }
    if p in ("estándar", "estandar"):
        return {
            "profiles": 3,
            "date_days": 3,
            "hours_rule": "whole_8_22",
            "interval_min": 60,
            "daily_messages_cap": 2000,     # <-- actualizado
        }
    if p == "premium":
        return {
            "profiles": 6,
            "date_days": 7,
            "hours_rule": "any",
            "interval_min": 1,
            "daily_messages_cap": 6000,     # <-- actualizado
        }
    if p == "admin":
        return {
            "profiles": 999,
            "date_days": 36500,
            "hours_rule": "any",
            "interval_min": 1,
            "daily_messages_cap": 10**9,
        }
    # plan desconocido
    return {
        "profiles": 0,
        "date_days": 0,
        "hours_rule": "even_8_20",
        "interval_min": 1020,
        "daily_messages_cap": 0,
    }

def hours_allowed(hours_rule: str, hh: int, mm: int) -> bool:
    if hours_rule == "any":
        return 0 <= hh <= 23 and 0 <= mm <= 59
    if hours_rule == "whole_8_22":
        return (8 <= hh <= 22) and (mm == 0)
    if hours_rule == "even_8_20":
        return (8 <= hh <= 20) and (mm == 0) and (hh % 2 == 0)
    return True

def ensure_daily_counter(u: dict):
    today = date.today().isoformat()
    if u.get("used_date") != today:
        u["used_date"] = today
        u["used_today"] = 0

# =============== /start & planes ===============
@bot.on(events.NewMessage(pattern=r"(?i)^/(?:start)(?:@[\w_]+)?(?:\s.*)?$"))
async def cmd_start(evt):
    uid = evt.sender_id
    u = load_user(uid)

    # Admin entra directo
    if str(uid) == str(ADMIN_ID):
        if u.get("plan_name") != "Admin":
            u["plan_name"] = "Admin"
            u["sub_expires"] = (date.today() + timedelta(days=36500)).isoformat()
            save_user(uid, u)
        texto, kb = render_panel(u)
        await evt.respond(texto, buttons=kb)
        return

    # Si no hay plan, o plan desconocido -> mostrar menú de planes
    if not u.get("plan_name") or (
        u.get("plan_name", "").lower() not in ("básico", "basico", "estándar", "estandar", "premium", "admin")
    ):
        text, kb = render_plans_compact_menu(u)
        await evt.respond(text, buttons=kb)
        return

    # Con plan
    texto, kb = render_panel(u)
    await evt.respond(texto, buttons=kb)

def render_plans_compact_menu(u=None):
    u = u or {}
    text = t(u, "PLANS_WELCOME")
    plans = load_plans()
    b = plans["basic"]["price_usdt"]
    s = plans["standard"]["price_usdt"]
    p = plans["premium"]["price_usdt"]
    kb = [
        [Button.inline(f"🔹Básico - {b:.2f} USDT", b"plan_pick_basic")],
        [Button.inline(f"🔹Estándar - {s:.2f} USDT", b"plan_pick_standard")],
        [Button.inline(f"🔹Premium - {p:.2f} USDT", b"plan_pick_premium")],
        [Button.inline(t(u, "BTN_HELP"), b"plans_help")],
    ]
    return text, kb

@bot.on(events.CallbackQuery(pattern=b"plans_help"))
async def cb_plans_help(event):
    u = load_user(event.sender_id)
    await event.answer(t(u, "PLANS_HELP_ALERT"), alert=True)

@bot.on(events.CallbackQuery(pattern=b"plan_pick_basic"))
async def cb_pick_basic(event):
    await event.answer()
    text, kb = plan_card_text_and_kb("basic")
    await event.edit(text, buttons=kb)

@bot.on(events.CallbackQuery(pattern=b"plan_pick_standard"))
async def cb_pick_standard(event):
    await event.answer()
    text, kb = plan_card_text_and_kb("standard")
    await event.edit(text, buttons=kb)

@bot.on(events.CallbackQuery(pattern=b"plan_pick_premium"))
async def cb_pick_premium(event):
    await event.answer()
    text, kb = plan_card_text_and_kb("premium")
    await event.edit(text, buttons=kb)

def plan_card_text_and_kb(plan_key: str):
    plans = load_plans()
    p = plans[plan_key]
    name = p["name"]
    price = p["price_usdt"]
    days = p["days"]

    if plan_key == "basic":
        text = (
            f"💎 **PLAN {name.upper()} — {price:.2f} USDT**\n\n"
            "📌 **Incluye:**\n"
            "   • 1 cuenta(s) vinculada(s)\n"
            "   • 500 mensajes diarios\n"  # <-- actualizado
            "   • Hasta 1 día(s) programables\n\n"
            "⚙️ **Características:**\n"
            "   • Intervalo mínimo: ⏱️ 120 min (fijo)\n"
            "   • Horarios permitidos: ⏰ Pares entre 08:00 y 20:00\n\n"
            f"📅 **Duración:** {days} días"
        )
        kb = [
            [Button.inline("➡️ Estándar", b"plan_pick_standard")],
            [Button.inline("💳 Comprar Básico", b"plan_buy_basic")],
        ]
        return text, kb

    if plan_key == "standard":
        text = (
            f"💎 **PLAN {name.upper()} — {price:.2f} USDT**\n\n"
            "📌 **Incluye:**\n"
            "   • 3 cuenta(s) vinculable(s)\n"
            "   • 2000 mensajes diarios\n"  # <-- actualizado
            "   • Hasta 3 día(s) programables\n\n"
            "⚙️ **Características:**\n"
            "   • Intervalo mínimo: ⏱️ 60 min\n"
            "   • Horarios permitidos: ⏰ Horas enteras de 08:00 a 22:00\n\n"
            f"📅 **Duración:** {days} días"
        )
        kb = [
            [Button.inline("⬅️ Básico", b"plan_pick_basic"), Button.inline("➡️ Premium", b"plan_pick_premium")],
            [Button.inline("💳 Comprar Estándar", b"plan_buy_standard")],
        ]
        return text, kb

    if plan_key == "premium":
        text = (
            f"💎 **PLAN {name.upper()} — {price:.2f} USDT**\n\n"
            "📌 **Incluye:**\n"
            "   • 6 cuenta(s) vinculable(s)\n"
            "   • 6000 mensajes diarios\n"  # <-- actualizado
            "   • Hasta 7 día(s) programables\n\n"
            "⚙️ **Características:**\n"
            "   • Intervalo mínimo: ⏱️ 1 min\n"
            "   • Horarios permitidos: ⏰ Cualquier hora y minuto\n\n"
            f"📅 **Duración:** {days} días"
        )
        kb = [
            [Button.inline("⬅️ Estándar", b"plan_pick_standard")],
            [Button.inline("💳 Comprar Premium", b"plan_buy_premium")],
        ]
        return text, kb

    return "Plan no disponible.", [[Button.inline("⬅️ Volver", b"plans_menu_compact")]]

@bot.on(events.CallbackQuery(pattern=b"plans_menu_compact"))
async def cb_plans_menu_compact(event):
    await event.answer()
    u = load_user(event.sender_id)
    text, kb = render_plans_compact_menu(u)
    await event.edit(text, buttons=kb)

@bot.on(events.CallbackQuery(pattern=b"plan_buy_"))
async def cb_plan_buy(event):
    await event.answer()
    plan_key = event.data.decode()[len("plan_buy_") :]
    plans = load_plans()
    if plan_key not in plans:
        await event.edit("Plan inválido.", buttons=[[Button.inline("⬅️ Volver", b"plans_menu_compact")]])
        return
    text = f"💠 Plan ({plans[plan_key]['name']}) seleccionado.\nElige la red para el pago:"
    kb = [
        [Button.inline("BEP20/ERC20", f"paynet_{plan_key}_BEP20_ERC20".encode())],
        [Button.inline("TRC-20", f"paynet_{plan_key}_TRC20".encode())],
        [Button.inline("SPL", f"paynet_{plan_key}_SPL".encode())],
        [Button.inline("JETTON", f"paynet_{plan_key}_JETTON".encode())],
        [Button.inline("⬅️ Volver", b"plans_menu_compact")],
    ]
    await event.edit(text, buttons=kb)

@bot.on(events.CallbackQuery(pattern=b"paynet_"))
async def cb_paynet(event):
    await event.answer()
    # formato: paynet_<plan>_<net>
    suffix = event.data.decode()[len("paynet_") :]
    if "_" not in suffix:
        await event.edit("Solicitud inválida.", buttons=[[Button.inline("⬅️ Volver", b"plans_menu_compact")]])
        return
    plan_key, net_key = suffix.split("_", 1)

    ensure_plans_defaults()
    ensure_pay_defaults()
    plans = load_plans()
    pays = load_pays()

    if plan_key not in plans:
        await event.edit("Plan inválido.", buttons=[[Button.inline("⬅️ Volver", b"plans_menu_compact")]])
        return
    if net_key not in pays:
        await event.edit(
            "Red inválida o no disponible.",
            buttons=[[Button.inline("⬅️ Volver", f"plan_buy_{plan_key}".encode())]],
        )
        return

    name = plans[plan_key]["name"]
    price = plans[plan_key]["price_usdt"]
    net = pays[net_key]["network"]
    addr = pays[net_key]["address"]

    text = (
        f"💠 **Plan ({name})**\n"
        f"🔹 **Red:** {net}\n"
        f"💰 **Monto a pagar:** {price} USDT\n"
        "📲 **Envía los USDT a la siguiente dirección:**\n"
        f"`{addr}`\n\n"
        "👉 Una vez realizado el pago, presiona **Ya realicé el pago**."
    )
    kb = [
        [Button.inline("💸 Ya realicé el pago", f"pay_done_{plan_key}_{net_key}".encode())],
        [Button.inline("⬅️ Volver", f"plan_buy_{plan_key}".encode())],
    ]
    await event.edit(text, buttons=kb)

@bot.on(events.CallbackQuery(pattern=b"pay_done_"))
async def cb_pay_done(event):
    await event.answer()
    # formato: pay_done_<plan>_<net>
    suffix = event.data.decode()[len("pay_done_") :]
    if "_" not in suffix:
        await event.edit("Solicitud inválida. Intenta de nuevo desde el menú de planes.")
        return
    plan_key, net_key = suffix.split("_", 1)

    ensure_plans_defaults()
    ensure_pay_defaults()
    plans = load_plans()
    pays = load_pays()

    if plan_key not in plans or net_key not in pays:
        await event.edit("Solicitud inválida. Intenta de nuevo desde el menú de planes.")
        return

    uid = event.sender_id
    name = plans[plan_key]["name"]
    net = pays[net_key]["network"]

    try:
        await bot.send_message(
            ADMIN_ID,
            (
                "📩 **Solicitud de pago recibida**\n\n"
                f"👤 Usuario: `{uid}`\n"
                f"💠 Plan: {name}\n"
                f"🔹 Red: {net}\n\n"
                "¿Quieres aprobar este pago?"
            ),
            buttons=[
                [
                    Button.inline("✅ Aceptar", f"admin_pay_ok_{uid}_{plan_key}".encode()),
                    Button.inline("❌ Rechazar", f"admin_pay_no_{uid}_{plan_key}".encode()),
                ]
            ],
        )
    except Exception:
        pass

    await event.edit("📨 Tu pago ha sido reportado. El administrador lo verificará y recibirás una respuesta pronto.")

@bot.on(events.CallbackQuery(pattern=b"admin_pay_ok_"))
async def admin_pay_ok(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True)
        return
    await event.answer()
    # formato: admin_pay_ok_<uid>_<plan>
    suffix = event.data.decode()[len("admin_pay_ok_") :]
    uid_str, plan_key = suffix.split("_", 1)
    uid = int(uid_str)
    plans = load_plans()
    p = plans.get(plan_key)
    if not p:
        await event.edit("Plan inválido.")
        return

    u = load_user(uid)
    u["plan_name"] = p["name"]
    u["sub_expires"] = (datetime.now() + timedelta(days=p["days"])).isoformat()
    save_user(uid, u)

    try:
        await bot.send_message(
            uid,
            (
                "✅ Tu pago ha sido confirmado.\n"
                f"🎉 El plan **{p['name']}** ahora está activo en tu cuenta.\n"
                f"📅 Vigencia: {p['days']} días\n\n"
                "¡Gracias por tu compra! 🚀"
            ),
        )
    except Exception:
        pass
    await event.edit(f"✅ Has aprobado el pago del usuario `{uid}` para el plan {p['name']}.")

@bot.on(events.CallbackQuery(pattern=b"admin_pay_no_"))
async def admin_pay_no(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True)
        return
    await event.answer()
    # formato: admin_pay_no_<uid>_<plan>
    suffix = event.data.decode()[len("admin_pay_no_") :]
    uid_str, plan_key = suffix.split("_", 1)
    uid = int(uid_str)
    plans = load_plans()
    p = plans.get(plan_key, {})
    try:
        await bot.send_message(uid, "❌ Tu pago ha sido rechazado por el administrador.")
    except Exception:
        pass
    await event.edit(f"❌ Has rechazado el pago del usuario {uid} para el plan {p.get('name','?')}.")

# =============== /dar_sub (admin) ===============
@bot.on(events.NewMessage(pattern=r"(?i)^/(?:dar_sub)(?:@[\w_]+)?(?:\s+.*)?$"))
async def cmd_dar_sub(evt):
    if str(evt.sender_id) != str(ADMIN_ID):
        await evt.respond("❌ Solo el admin puede usar este comando.")
        return

    parts = (evt.raw_text or "").strip().split()
    if len(parts) < 4:
        await evt.respond("Uso: `/dar_sub {user_id} {plan} {días}`\n"
                          "Ej: `/dar_sub 123456789 Básico 30`", parse_mode="md")
        return

    try:
        target_uid = int(parts[1])
    except Exception:
        await evt.respond("❌ `user_id` inválido. Debe ser numérico.", parse_mode="md")
        return

    plan_input = parts[2]
    try:
        add_days = int(parts[3])
    except Exception:
        await evt.respond("❌ `días` inválido. Debe ser entero positivo.", parse_mode="md")
        return
    if add_days <= 0:
        await evt.respond("❌ `días` debe ser > 0.", parse_mode="md")
        return

    plan_key = _resolve_plan_key(plan_input)
    if not plan_key:
        await evt.respond("❌ Plan inválido. Usa: Básico / Estándar / Premium / Admin.")
        return

    plans = load_plans()
    if plan_key not in plans:
        await evt.respond("❌ Plan no disponible en la configuración.")
        return

    plan_name = plans[plan_key]["name"]  # "Básico", "Estándar", etc.

    # Cargar usuario y REEMPLAZAR expiración (no sumar)
    u = load_user(target_uid)
    today_ = date.today()
    new_exp = today_ + timedelta(days=add_days)

    u["plan_name"] = plan_name
    u["sub_expires"] = new_exp.isoformat()  # YYYY-MM-DD
    save_user(target_uid, u)

    await evt.respond(
        f"✅ Asignado **{plan_name}** a `{target_uid}` por **{add_days}** día(s).\n"
        f"📅 Nueva expiración: **{u['sub_expires']}**",
        parse_mode="md"
    )

    try:
        await bot.send_message(
            target_uid,
            f"🎟️ Se te ha otorgado el plan **{plan_name}** por **{add_days}** día(s).\n"
            f"📅 Expira el: **{u['sub_expires']}**"
        )
    except Exception:
        pass

# =============== /admin_panel (solo admin) ===============
def render_admin_panel():
    texto = (
        "🛠️ **Panel de Administración**\n\n"
        "Elige una opción:"
    )
    kb = [
        [Button.inline("👁️ Ver suscripción", b"adm_view_sub")],
        [Button.inline("👥 Ver usuarios (activos)", b"adm_list_users")],
        [Button.inline("📂 Carpetas de usuario", b"adm_user_folders_btn")],
        [Button.inline("🎟️ Dar suscripción", b"adm_give_sub")],
        [Button.inline("🚫 Bloquear usuario", b"adm_block_user")],
        [Button.inline("📋 Ver bloqueados", b"adm_list_blocked")],
        [Button.inline("🔓 Desbloquear usuario", b"adm_unblock_user")],
    ]
    return texto, kb

@bot.on(events.CallbackQuery(pattern=rb"^adm_user_folders_btn$"))
async def adm_user_folders_btn(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True); return
    PENDING[event.sender_id] = {"mode": "adm_user_folders_ask"}
    await event.respond("📝 Envía el `user_id` del usuario cuyas carpetas quieres ver.", parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^adm_list_users$"))
async def adm_list_users(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True); return
    await event.answer()

    # Recolecta usuarios con plan ACTIVO
    users = []
    try:
        for fname in os.listdir(DATA):
            if not fname.endswith(".json"): continue
            uid_str = fname[:-5]
            if not uid_str.isdigit(): continue
            uid = int(uid_str)
            u = load_user(uid)
            if is_sub_active(uid, u):
                plan = u.get("plan_name") or "—"
                exp = u.get("sub_expires") or "—"
                dcount = len(flatten_destinations_from_sets(u))
                mcount = len(flatten_messages_from_sets(u))
                users.append((uid, plan, exp, dcount, mcount))
    except Exception:
        pass

    if not users:
        try:
            await event.edit("ℹ️ No hay usuarios con plan activo.", buttons=[[Button.inline("⬅️ Volver", b"adm_back_admin")]])
        except Exception:
            await event.respond("ℹ️ No hay usuarios con plan activo.", buttons=[[Button.inline("⬅️ Volver", b"adm_back_admin")]])
        return

    users.sort(key=lambda x: x[0])
    lines = [f"• `{uid}` | {plan} | exp: {exp} | 🎯 {d} | 💬 {m}" for uid,plan,exp,d,m in users[:50]]
    extra = "" if len(users) <= 50 else f"\n… y {len(users)-50} más."
    txt = "👥 **Usuarios con plan activo**\n\n" + "\n".join(lines) + extra
    try:
        await event.edit(txt, buttons=[[Button.inline("⬅️ Volver", b"adm_back_admin")]], parse_mode="md")
    except Exception:
        await event.respond(txt, buttons=[[Button.inline("⬅️ Volver", b"adm_back_admin")]], parse_mode="md")


@bot.on(events.CallbackQuery(pattern=rb"^adm_user_folders$"))
async def adm_user_folders_btn(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True); return
    await event.answer()
    PENDING[event.sender_id] = {"mode": "adm_user_folders"}
    await event.respond("📝 Envía el `user_id` del usuario para listar **carpetas y chats**.", parse_mode="md")

@bot.on(events.NewMessage(pattern=r"(?i)^/(?:admin_panel)(?:@[\w_]+)?$"))
async def admin_panel(evt):
    if str(evt.sender_id) != str(ADMIN_ID):
        await evt.respond("❌ Solo el admin puede usar este panel.")
        return
    texto, kb = render_admin_panel()
    await evt.respond(texto, buttons=kb)

@bot.on(events.CallbackQuery(pattern=rb"^adm_back_admin$"))
async def adm_back_admin(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True); return
    await event.answer()
    texto, kb = render_admin_panel()
    try:
        await event.edit(texto, buttons=kb)
    except Exception:
        await event.respond(texto, buttons=kb)

# =============== PANEL PRINCIPAL ===============
def render_panel(u):
    # Asegurar estructuras de conjuntos
    u = ensure_sets_defaults(u)

    # Totales reales por conjuntos
    total_destinos = sum(len(v.get("ids", [])) for v in u.get("dest_sets", {}).values())
    total_msgs = sum(len(v.get("items", [])) for v in u.get("msg_sets", {}).values())

    # Capacidad diaria según plan + consumo de hoy
    policy = plan_policy(u.get("plan_name"))
    ensure_daily_counter(u)  # resetea contador si cambió el día
    cap = policy.get("daily_messages_cap", 0)
    used = int(u.get("used_today") or 0)
    remaining = max(0, cap - used)

    tz = u.get("timezone", "UTC")
    texto = (
        t(u, "PANEL_TITLE") + "\n\n" +
        t(u, "SCHEDULE_LINE",
            hs=f"{u['hour_start']:02d}",
            ms=f"{u['min_start']:02d}",
            he=f"{u['hour_end']:02d}",
            me=f"{u['min_end']:02d}",
            tz=tz) + "\n" +
        t(u, "DATE_LINE", date=(u.get('program_date') or date.today().isoformat())) + "\n" +
        t(u, "INTERVAL_LINE", interval=u.get("interval_min", 0)) + "\n" +
        t(u, "DEST_COUNT_LINE", d=total_destinos, ds=len(u.get('dest_sets', {}))) + "\n" +
        t(u, "MSG_COUNT_LINE",  m=total_msgs,    ms=len(u.get('msg_sets', {}))) + "\n" +
        t(u, "DAILY_CAP_LINE", cap=cap, used=used, remaining=remaining) + "\n" +   # <-- NUEVA LÍNEA
        t(u, "SUB_LINE",  days=remaining_days(u)) + "\n" +
        t(u, "PLAN_LINE", plan=u.get('plan_name', '—')) + "\n" +
        t(u, "LANG_LINE", lang=(u.get('lang', 'es').upper())) + "\n\n" +
        t(u, "ACCOUNTS_HDR") + "\n" +
        (
            "\n".join([t(u, "ACC_LABEL", phone=a.get('phone'), uid=a.get('user_id'))
                       for a in (u.get('accounts') or [])])
            if (u.get("accounts") or [])
            else t(u, "NO_ACCOUNTS")
        )
    )
    kb = [
        [Button.inline(t(u, "BTN_DM"),        b"menu_dm")],
        [Button.inline(t(u, "BTN_HD"),        b"menu_hd")],
        [Button.inline(t(u, "BTN_ACC"),       b"menu_acc")],
        [Button.inline(t(u, "BTN_PROG"),      b"menu_prog")],
        [Button.inline(t(u, "BTN_LANG_MENU"), b"menu_lang")],
    ]
    return texto, kb

@bot.on(events.CallbackQuery(pattern=b"back_panel"))
async def back_panel(event):
    u = load_user(event.sender_id)
    if not is_sub_active(event.sender_id, u):
        text, kb = render_plans_compact_menu(u)
        await event.edit(text, buttons=kb)
        return
    texto, kb = render_panel(u)
    await event.edit(texto, buttons=kb)

# =============== MENÚ: Horario & Días ===============
@bot.on(events.CallbackQuery(pattern=b"menu_hd"))
@plan_guard
async def menu_hd(event):
    u = load_user(event.sender_id)
    texto = (
        t(u, "HD_TITLE") + "\n\n" +
        t(u, "SCHEDULE_LINE", hs=f"{u['hour_start']:02d}", ms=f"{u['min_start']:02d}", he=f"{u['hour_end']:02d}", me=f"{u['min_end']:02d}", tz=u.get('timezone','UTC')) + "\n" +
        t(u, "DATE_LINE", date=u.get('program_date')) + "\n" +
        t(u, "INTERVAL_LINE", interval=u.get("interval_min",0)) + "\n" +
        t(u, "TZ_LINE", tz=u.get("timezone","UTC")) + "\n\n" +
        t(u, "HD_INFO")
    )
    kb = [
        [Button.inline(t(u, "BTN_HSTART"), b"set_hini"), Button.inline(t(u, "BTN_HEND"), b"set_hfin")],
        [Button.inline(t(u, "BTN_FPROG"), b"set_fprog"), Button.inline(t(u, "BTN_INTERVAL"), b"set_interval")],
        [Button.inline(t(u, "BTN_TZ"), b"set_tz")],
        [Button.inline(t(u, "BTN_BACK"), b"back_panel")],
    ]
    await event.edit(texto, buttons=kb)

@bot.on(events.CallbackQuery(pattern=b"set_hini"))
@plan_guard
async def set_hini(event):
    PENDING[event.sender_id] = {"mode": "set_hini"}
    await event.respond("Envíame la hora de inicio en formato HH:MM (24h).")

@bot.on(events.CallbackQuery(pattern=b"set_hfin"))
@plan_guard
async def set_hfin(event):
    PENDING[event.sender_id] = {"mode": "set_hfin"}
    await event.respond("Envíame la hora de fin en formato HH:MM (24h).")

@bot.on(events.CallbackQuery(pattern=b"set_fprog"))
@plan_guard
async def set_fprog(event):
    PENDING[event.sender_id] = {"mode": "set_fprog"}
    await event.respond("Envíame la fecha programada (AAAA-MM-DD).")

@bot.on(events.CallbackQuery(pattern=b"set_interval"))
@plan_guard
async def set_interval(event):
    PENDING[event.sender_id] = {"mode": "set_interval"}
    await event.respond("Envíame el intervalo en minutos (entero > 0).")

# =============== Zona horaria: lista rápida + por cuenta ===============
COMMON_TZ = [
    "America/Havana", "America/New_York", "America/Mexico_City",
    "America/Bogota", "America/Lima", "America/Sao_Paulo",
    "Europe/Madrid", "Europe/London", "Europe/Berlin", "Europe/Moscow",
    "Asia/Dubai", "Asia/Tokyo"
]

@bot.on(events.CallbackQuery(pattern=rb"^set_tz$"))
@plan_guard
async def set_tz(event):
    u = load_user(event.sender_id)
    PENDING[event.sender_id] = {"mode": "set_tz"}
    rows = []
    row = []
    for tz in COMMON_TZ:
        row.append(Button.inline(tz, f"tz_{tz}".encode()))
        if len(row) == 2:
            rows.append(row); row = []
    if row: rows.append(row)
    rows.append([Button.inline(t(u, "BTN_TZ_MANUAL"), b"tz_manual")])
    rows.append([Button.inline(t(u, "BTN_TZ_PERACC"), b"tz_per_acc")])
    rows.append([Button.inline(t(u, "BTN_BACK"), b"menu_hd")])
    await event.edit(t(u, "TZ_PICK_PROMPT"), buttons=rows)

@bot.on(events.CallbackQuery(pattern=rb"^tz_manual$"))
@plan_guard
async def tz_manual(event):
    u = load_user(event.sender_id)
    PENDING[event.sender_id] = {"mode": "set_tz"}
    await event.respond(t(u, "TZ_MANUAL_PROMPT"))

@bot.on(events.CallbackQuery(pattern=rb"^tz_.+"))
@plan_guard
async def tz_pick_quick(event):
    u = load_user(event.sender_id)
    tzname = event.data.decode()[3:]
    try:
        pytz.timezone(tzname)
    except Exception:
        await event.answer("TZ inválida", alert=True); return
    u["timezone"]=tzname; save_user(event.sender_id,u)
    await event.edit(t(u, "TZ_SET_GLOBAL_OK", tz=tzname), buttons=[[Button.inline(t(u, "BTN_BACK"), b"menu_hd")]], parse_mode="md")

# ----- Zona por cuenta -----
@bot.on(events.CallbackQuery(pattern=rb"^tz_per_acc$"))
@plan_guard
async def tz_per_acc(event):
    u = load_user(event.sender_id)
    accs = u.get("accounts") or []
    if not accs:
        await event.answer("No hay cuentas.", alert=True); return
    kb=[]
    for i,a in enumerate(accs[:10]):
        kb.append([Button.inline(f"👤 {a.get('phone')}", f"tzacc_{i}".encode())])
    kb.append([Button.inline(t(u, "BTN_BACK"), b"set_tz")])
    await event.edit(t(u, "TZ_PICK_ACC"), buttons=kb)

@bot.on(events.CallbackQuery(pattern=rb"^tzacc_\d+$"))
@plan_guard
async def tzacc_pick(event):
    u = load_user(event.sender_id)
    idx = int(event.data.decode().split("_")[-1])
    accs = u.get("accounts") or []
    if not (0 <= idx < len(accs)):
        await event.answer(t(u, "ERR_INDEX"), alert=True); return
    PENDING[event.sender_id] = {"mode":"set_tz_acc","acc_index":idx}
    rows=[]; row=[]
    for tz in COMMON_TZ:
        row.append(Button.inline(tz, f"tzaccset_{idx}_{tz}".encode()))
        if len(row)==2: rows.append(row); row=[]
    if row: rows.append(row)
    rows.append([Button.inline(t(u, "BTN_TZ_MANUAL"), f"tzacc_manual_{idx}".encode())])
    rows.append([Button.inline(t(u, "BTN_BACK"), b"tz_per_acc")])
    await event.edit(t(u, "TZ_PICK_FOR_ACC"), buttons=rows)

@bot.on(events.CallbackQuery(pattern=rb"^tzaccset_\d+_.+"))
@plan_guard
async def tzacc_set_quick(event):
    u = load_user(event.sender_id)
    _, rest = event.data.decode().split("tzaccset_",1)
    idx_str, tzname = rest.split("_",1)
    idx = int(idx_str)
    try:
        pytz.timezone(tzname)
    except Exception:
        await event.answer("TZ inválida", alert=True); return
    accs = u.get("accounts") or []
    if not (0 <= idx < len(accs)):
        await event.answer(t(u, "ERR_INDEX"), alert=True); return
    u.setdefault("account_tz", {})
    uid_acc = str(accs[idx].get("user_id"))
    u["account_tz"][uid_acc] = tzname
    save_user(event.sender_id, u)
    await event.edit(t(u, "TZ_SET_ACC_OK", tz=tzname), buttons=[[Button.inline(t(u, "BTN_BACK"), b"tz_per_acc")]], parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^tzacc_manual_\d+$"))
@plan_guard
async def tzacc_manual(event):
    u = load_user(event.sender_id)
    idx = int(event.data.decode().split("_")[-1])
    PENDING[event.sender_id] = {"mode":"set_tz_acc_manual","acc_index":idx}
    await event.respond(t(u, "TZ_ACC_MANUAL_PROMPT"))

# =============== MENÚ: Destinos & Mensajes ===============
@bot.on(events.CallbackQuery(pattern=rb"^menu_dm$"))
@plan_guard
async def menu_dm(event):
    u = load_user(event.sender_id)
    u = ensure_sets_defaults(u)
    d = sum(len(v["ids"]) for v in u["dest_sets"].values())
    m = sum(len(v["items"]) for v in u["msg_sets"].values())
    texto = (
        t(u, "SET_MGMT_TITLE") + "\n\n" +
        t(u, "SET_DEST_LINE", d=d, ds=len(u["dest_sets"])) + "\n" +
        t(u, "SET_MSG_LINE", m=m, ms=len(u["msg_sets"])) + "\n\n" +
        "Crea, edita y usa conjuntos con nombre."
    )
    kb = [
        [Button.inline(t(u, "BTN_SETS_DEST"), b"dm_sets_dest")],
        [Button.inline(t(u, "BTN_SETS_MSG"), b"dm_sets_msg")],
        [Button.inline(t(u, "BTN_BACK"), b"back_panel")],
    ]
    await event.edit(texto, buttons=kb)

# ======= DEST SETS =======
@bot.on(events.CallbackQuery(pattern=rb"^dm_sets_dest$"))
@plan_guard
async def dm_sets_dest(event):
    u = load_user(event.sender_id)
    u = ensure_sets_defaults(u)
    lines = []
    for k, v in u["dest_sets"].items():
        lines.append(f"• {v['name']}  (`{k}`) — {len(v['ids'])} destinos")
    txt = t(u, "BTN_SETS_DEST") + "\n\n" + ("\n".join(lines) if lines else t(u, "NO_SETS"))
    kb = [
        [Button.inline(t(u, "BTN_CREATE_SET"), b"ds_new")],
    ]
    for k, v in list(u["dest_sets"].items())[:8]:
        kb.append([Button.inline(f"✏️ {v['name']}", f"ds_edit_{k}".encode())])
    kb.append([Button.inline(t(u, "BTN_BACK"), b"menu_dm")])
    await event.edit(txt, buttons=kb, parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^ds_new$"))
@plan_guard
async def ds_new(event):
    PENDING[event.sender_id] = {"mode": "ds_new_name"}
    await event.respond("Nombre para el **conjunto de destinos**:", parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^ds_edit_"))
@plan_guard
async def ds_edit(event):
    u = load_user(event.sender_id)
    key = event.data.decode().split("_", 2)[2]
    u = ensure_sets_defaults(u)
    v = u["dest_sets"].get(key)
    if not v:
        await event.answer("Conjunto no existe.", alert=True); return
    txt = t(u, "DS_TITLE", name=v['name'], key=key, n=len(v['ids']))
    kb = [
        [Button.inline(t(u, "BTN_ADD_DEST"), f"ds_add_{key}".encode())],
        [Button.inline(t(u, "BTN_REMOVE_DEST"), f"ds_del_{key}".encode())],
        [Button.inline(t(u, "BTN_RENAME"), f"ds_rename_{key}".encode())],
        [Button.inline(t(u, "BTN_DROP"), f"ds_drop_{key}".encode())],
        [Button.inline(t(u, "BTN_BACK"), b"dm_sets_dest")],
    ]
    await event.edit(txt, buttons=kb, parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^ds_add_"))
@plan_guard
async def ds_add(event):
    key = event.data.decode().split("_", 2)[2]
    u = load_user(event.sender_id)
    if key not in ensure_sets_defaults(u)["dest_sets"]:
        await event.answer("Conjunto no existe.", alert=True); return
    PENDING[event.sender_id] = {"mode": "ds_add_lines", "key": key}
    await event.respond("Envía destinos (uno por línea): @usuario, t.me/..., o ID numérico.")

@bot.on(events.CallbackQuery(pattern=rb"^ds_del_"))
@plan_guard
async def ds_del(event):
    key = event.data.decode().split("_", 2)[2]
    u = load_user(event.sender_id)
    if key not in ensure_sets_defaults(u)["dest_sets"]:
        await event.answer("Conjunto no existe.", alert=True); return
    PENDING[event.sender_id] = {"mode": "ds_remove_lines", "key": key}
    await event.respond("Envía destinos a quitar (formato libre: @, link o ID).")

@bot.on(events.CallbackQuery(pattern=rb"^ds_rename_"))
@plan_guard
async def ds_rename(event):
    key = event.data.decode().split("_", 2)[2]
    u = load_user(event.sender_id)
    if key not in ensure_sets_defaults(u)["dest_sets"]:
        await event.answer("Conjunto no existe.", alert=True); return
    PENDING[event.sender_id] = {"mode": "ds_rename", "key": key}
    await event.respond("Nuevo **nombre** del conjunto:", parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^ds_drop_"))
@plan_guard
async def ds_drop(event):
    key = event.data.decode().split("_", 2)[2]
    u = load_user(event.sender_id)
    u = ensure_sets_defaults(u)
    if key not in u["dest_sets"]:
        await event.answer("Conjunto no existe.", alert=True); return
    u["dest_sets"].pop(key, None)
    save_user(event.sender_id, u)
    await event.edit("✅ Conjunto eliminado.", buttons=[[Button.inline(t(u, "BTN_BACK"), b"dm_sets_dest")]])

# ======= MSG SETS =======
@bot.on(events.CallbackQuery(pattern=rb"^dm_sets_msg$"))
@plan_guard
async def dm_sets_msg(event):
    u = load_user(event.sender_id)
    u = ensure_sets_defaults(u)
    lines = []
    for k, v in u["msg_sets"].items():
        lines.append(f"• {v['name']}  (`{k}`) — {len(v['items'])} mensajes")
    txt = t(u, "BTN_SETS_MSG") + "\n\n" + ("\n".join(lines) if lines else t(u, "NO_SETS"))
    kb = [[Button.inline(t(u, "BTN_CREATE_SET"), b"ms_new")]]
    for k, v in list(u["msg_sets"].items())[:8]:
        kb.append([Button.inline(f"✏️ {v['name']}", f"ms_edit_{k}".encode())])
    kb.append([Button.inline(t(u, "BTN_BACK"), b"menu_dm")])
    await event.edit(txt, buttons=kb, parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^ms_new$"))
@plan_guard
async def ms_new(event):
    PENDING[event.sender_id] = {"mode": "ms_new_name"}
    await event.respond("Nombre para el **conjunto de mensajes**:", parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^ms_edit_"))
@plan_guard
async def ms_edit(event):
    u = load_user(event.sender_id)
    key = event.data.decode().split("_", 2)[2]
    u = ensure_sets_defaults(u)
    v = u["msg_sets"].get(key)
    if not v:
        await event.answer("Conjunto no existe.", alert=True); return
    txt = t(u, "MS_TITLE", name=v['name'], key=key, n=len(v['items']))
    kb = [
        [Button.inline(t(u, "BTN_ADD_FROM_SAVED"), f"ms_add_{key}".encode())],
        [Button.inline(t(u, "BTN_ADD_FROM_PEER"), f"ms_add_from_peer_{key}".encode())],
        [Button.inline(t(u, "BTN_REMOVE_MSG"), f"ms_del_{key}".encode())],
        [Button.inline(t(u, "BTN_RENAME"), f"ms_rename_{key}".encode())],
        [Button.inline(t(u, "BTN_DROP"), f"ms_drop_{key}".encode())],
        [Button.inline(t(u, "BTN_BACK"), b"dm_sets_msg")],
    ]
    await event.edit(txt, buttons=kb, parse_mode="md")

# Añadir mensajes desde Canal/Grupo
@bot.on(events.CallbackQuery(pattern=rb"^ms_add_from_peer_"))
@plan_guard
async def ms_add_from_peer(event):
    key = event.data.decode().split("_", 4)[4]  # ms_add_from_peer_{key}
    u = load_user(event.sender_id); u = ensure_sets_defaults(u)
    if key not in u["msg_sets"]:
        await event.answer("Conjunto no existe.", alert=True); return
    PENDING[event.sender_id] = {"mode":"ms_add_peer_step1","key":key}
    await event.respond("Envía el @usuario del canal/grupo o el enlace t.me/...")

@bot.on(events.CallbackQuery(pattern=rb"^ms_add_"))
@plan_guard
async def ms_add(event):
    key = event.data.decode().split("_", 2)[2]
    u = load_user(event.sender_id)
    if key not in ensure_sets_defaults(u)["msg_sets"]:
        await event.answer("Conjunto no existe.", alert=True); return
    PENDING[event.sender_id] = {"mode": "ms_add_ids", "key": key}
    await event.respond("Envía **IDs** de Mensajes guardados (separados por espacios/comas/líneas).", parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^ms_del_"))
@plan_guard
async def ms_del(event):
    key = event.data.decode().split("_", 2)[2]
    u = load_user(event.sender_id)
    if key not in ensure_sets_defaults(u)["msg_sets"]:
        await event.answer("Conjunto no existe.", alert=True); return
    PENDING[event.sender_id] = {"mode": "ms_remove_ids", "key": key}
    await event.respond("Envía **IDs** a quitar del conjunto.", parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^ms_rename_"))
@plan_guard
async def ms_rename(event):
    key = event.data.decode().split("_", 2)[2]
    u = load_user(event.sender_id)
    if key not in ensure_sets_defaults(u)["msg_sets"]:
        await event.answer("Conjunto no existe.", alert=True); return
    PENDING[event.sender_id] = {"mode": "ms_rename", "key": key}
    await event.respond("Nuevo **nombre** del conjunto:", parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^ms_drop_"))
@plan_guard
async def ms_drop(event):
    key = event.data.decode().split("_", 2)[2]
    u = load_user(event.sender_id); u = ensure_sets_defaults(u)
    if key not in u["msg_sets"]:
        await event.answer("Conjunto no existe.", alert=True); return
    u["msg_sets"].pop(key, None)
    save_user(event.sender_id, u)
    await event.edit("✅ Conjunto eliminado.", buttons=[[Button.inline(t(u, "BTN_BACK"), b"dm_sets_msg")]])

# =============== MENÚ: Programar (UNIFICADO, sin duplicados) ===============
@bot.on(events.CallbackQuery(pattern=rb"^menu_prog$"))
@plan_guard
async def menu_prog(event):
    uid = event.sender_id
    u = load_user(uid)
    accs = u.get("accounts") or []
    if not accs:
        await event.edit(t(u,"NO_ACCOUNTS_LINKED"), buttons=[[Button.inline(t(u,"BTN_BACK"), b"back_panel")]], parse_mode="md")
        return
    kb = []
    for i, a in enumerate(accs[:10]):
        lab = t(u,"ACC_LABEL", phone=a.get('phone'), uid=a.get('user_id','?'))
        kb.append([Button.inline(lab, f"pr_pick_acc_{i}".encode())])
    kb.append([Button.inline(t(u,"BTN_BACK"), b"back_panel")])
    await event.edit(t(u,"PROG_PICK_PROFILE"), buttons=kb, parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^pr_pick_acc_"))
@plan_guard
async def pr_pick_acc(event):
    uid = event.sender_id
    idx = int(event.data.decode().split("_")[-1])
    u = load_user(uid); accs = u.get("accounts") or []
    if not (0 <= idx < len(accs)):
        await event.answer(t(u,"ERR_INDEX"), alert=True); return
    # SIEMPRE listas para PENDING
    PENDING[uid] = {"mode": "pr_choose_sets", "acc_index": idx, "dest_sel": [], "msg_sel": []}
    await render_pick_sets(event, u)

async def render_pick_sets(event, u):
    uid = event.sender_id
    st = PENDING.get(uid) or {}
    # Convertir a set solo para marcar
    sel_ds = set(st.get("dest_sel") or [])
    sel_ms = set(st.get("msg_sel") or [])
    ds = u.get("dest_sets", {})
    ms = u.get("msg_sets", {})
    kb = []
    if ds:
        for k, v in list(ds.items())[:10]:
            mark = "✅" if k in sel_ds else "⚪"
            kb.append([Button.inline(f"{mark} {t(u,'LBL_DEST')}: {v['name']}", f"pr_tog_ds_{k}".encode())])
    else:
        kb.append([Button.inline(t(u,"NO_DEST_SETS"), b"noop")])
    if ms:
        for k, v in list(ms.items())[:10]:
            mark = "✅" if k in sel_ms else "⚪"
            kb.append([Button.inline(f"{mark} {t(u,'LBL_MSG')}: {v['name']}", f"pr_tog_ms_{k}".encode())])
    else:
        kb.append([Button.inline(t(u,"NO_MSG_SETS"), b"noop")])
    kb.append([Button.inline(t(u,"BTN_CONTINUE"), b"pr_sets_next")])
    kb.append([Button.inline(t(u,"BTN_BACK"), b"menu_prog")])
    await event.edit(t(u,"PROG_SELECT_SETS"), buttons=kb, parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^pr_tog_ds_"))
@plan_guard
async def pr_tog_ds(event):
    uid = event.sender_id
    key = event.data.decode().split("_", 3)[3]
    st = PENDING.get(uid) or {}
    cur = list(st.get("dest_sel") or [])
    if key in cur:
        cur.remove(key)
    else:
        cur.append(key)
    st["dest_sel"] = cur
    PENDING[uid] = st
    await render_pick_sets(event, load_user(uid))

@bot.on(events.CallbackQuery(pattern=rb"^pr_tog_ms_"))
@plan_guard
async def pr_tog_ms(event):
    uid = event.sender_id
    key = event.data.decode().split("_", 3)[3]
    st = PENDING.get(uid) or {}
    cur = list(st.get("msg_sel") or [])
    if key in cur:
        cur.remove(key)
    else:
        cur.append(key)
    st["msg_sel"] = cur
    PENDING[uid] = st
    await render_pick_sets(event, load_user(uid))

@bot.on(events.CallbackQuery(pattern=rb"^pr_sets_next$"))
@plan_guard
async def pr_sets_next(event):
    uid = event.sender_id
    u = load_user(uid)
    st = PENDING.get(uid) or {}
    if not st.get("dest_sel") or not st.get("msg_sel"):
        await event.answer(t(u,"ERR_NEED_SETS"), alert=True); return

    # Construir listas a partir de sets
    dest_ids = []
    for k in st["dest_sel"]:
        dest_ids.extend(u["dest_sets"].get(k, {}).get("ids", []))
    msgs = []
    for k in st["msg_sel"]:
        msgs.extend(u["msg_sets"].get(k, {}).get("items", []))

    if not dest_ids:
        await event.edit(t(u,"ERR_NO_DEST_IN_SETS")); return
    if not msgs:
        await event.edit(t(u,"ERR_NO_MSG_IN_SETS")); return

    # Guardar en pending para el programador
    st["dest_ids"] = list(dict.fromkeys(dest_ids))  # dedupe
    seen = set(); dedup = []
    for x in msgs:
        k = (x["chat_id"], x["message_id"])
        if k in seen: continue
        seen.add(k); dedup.append(x)
    st["msgs"] = dedup
    st["mode"] = "pr_ready"
    PENDING[uid] = st

    await event.edit(t(u,"SETS_OK_START"), buttons=[
        [Button.inline(t(u,"BTN_START"), b"pr_start_with_sets")],
        [Button.inline(t(u,"BTN_BACK"), b"menu_prog")]
    ], parse_mode="md")

# =============== PROGRAMACIÓN: helpers y ejecución ===============
async def fetch_message_with(client, chat_id, mid):
    try:
        ent = await client.get_entity(chat_id)
        msgs = await client.get_messages(ent, ids=[mid])
        return msgs[0] if msgs and msgs[0] else None
    except Exception:
        return None

@bot.on(events.CallbackQuery(pattern=rb"^pr_start_with_sets$"))
@plan_guard
async def pr_start_with_sets(event):
    uid = event.sender_id
    st = PENDING.get(uid) or {}
    if st.get("mode") != "pr_ready":
        await event.edit("Estado inválido. Vuelve a **Programar**.", buttons=[[Button.inline("⬅️ Volver", b"menu_prog")]])
        return

    u = load_user(uid)
    u["_tmp_destinations"]=st["dest_ids"]
    u["_tmp_messages"]=st["msgs"]
    save_user(uid,u)

    await pr_start_run(event, use_tmp=True)

async def pr_start_run(event, use_tmp: bool=False):
    uid = event.sender_id
    u = load_user(uid)

    # listas desde conjuntos (tmp) o globales
    if use_tmp:
        dest_ids = list(u.get("_tmp_destinations") or [])
        msgs     = list(u.get("_tmp_messages") or [])
    else:
        dest_ids = list(u.get("destinations") or [])
        msgs     = list(u.get("messages") or [])

    if not dest_ids:
        await event.edit("⚠️ No hay **destinos** seleccionados.", buttons=[[Button.inline(t(u,"BTN_BACK"), b"menu_prog")]]); return
    if not msgs:
        await event.edit("⚠️ No hay **mensajes** seleccionados.", buttons=[[Button.inline(t(u,"BTN_BACK"), b"menu_prog")]]); return

    client, err = await ensure_user_client(uid)
    if err:
        await event.edit(err, buttons=[[Button.inline(t(u,"BTN_BACK"), b"menu_prog")]])
        return

    # Timezone: por cuenta > global
    accs = u.get("accounts") or []
    acc_index = (PENDING.get(uid) or {}).get("acc_index", 0)
    tzname = None
    if accs and u.get("account_tz"):
        uid_acc = str(accs[acc_index].get("user_id"))
        tzname = u["account_tz"].get(uid_acc)
    if not tzname:
        tzname = u.get("timezone","UTC")
    tz = get_tz(tzname)

    # Ventana local -> UTC
    try:
        y, m, d = map(int, (u.get("program_date") or date.today().isoformat()).split("-"))
        hs, ms_ = u["hour_start"], u["min_start"]
        he, me_ = u["hour_end"],   u["min_end"]
        start_local = tz.localize(datetime(y, m, d, hs, ms_, 0))
        end_local   = tz.localize(datetime(y, m, d, he, me_, 0))
        if end_local <= start_local:
            await event.edit("⚠️ La hora de fin debe ser mayor que la de inicio.", buttons=[[Button.inline(t(u,"BTN_BACK"), b"menu_prog")]])
            await client.disconnect()
            return
        start_dt = start_local.astimezone(utc)
        end_dt   = end_local.astimezone(utc)
    except Exception:
        await event.edit("⚠️ Fecha u horario inválidos.", buttons=[[Button.inline(t(u,"BTN_BACK"), b"menu_prog")]])
        await client.disconnect()
        return

    interval = max(1, int(u.get("interval_min", 120)))
    slots = []
    cur = start_dt
    now = datetime.now(utc)
    while cur <= end_dt:
        if cur > now:
            slots.append(cur)
        cur += timedelta(minutes=interval)
    if not slots:
        await event.edit("⚠️ No hay ranuras futuras en la franja (revisa hora/fecha/intervalo).", buttons=[[Button.inline(t(u,"BTN_BACK"), b"menu_prog")]])
        await client.disconnect()
        return

    # Vista bonita de destinos
    dest_view = {}
    for pid in dest_ids:
        try:
            ent = await client.get_entity(pid)
            dest_view[pid] = pretty_entity_name(ent)
        except Exception:
            dest_view[pid] = str(pid)

    policy = plan_policy(u.get("plan_name"))
    ensure_daily_counter(u); save_user(uid, u)

    ops_total = len(slots) * len(dest_ids)
    cap = policy["daily_messages_cap"]
    used = u.get("used_today", 0)
    remaining = max(0, cap - used)
    if remaining <= 0:
        await event.edit(f"🔒 Alcanzaste tu límite diario de **{cap}** mensajes.")
        await client.disconnect()
        return

    if ops_total > remaining:
        max_ops = remaining
        limited_pairs = []
        count = 0
        for s in slots:
            for dpid in dest_ids:
                limited_pairs.append((s, dpid))
                count += 1
                if count >= max_ops:
                    break
            if count >= max_ops:
                break
    else:
        limited_pairs = [(s, dpid) for s in slots for dpid in dest_ids]

    total_ops = len(limited_pairs)
    done=0; ok=0; fail=0
    started=time.time()
    prog = await event.respond("🚀 Preparando…")

    def _progress_bar(cur, total, width=20):
        if total <= 0: return "—"
        ratio = max(0.0, min(1.0, cur / total))
        fill = int(ratio * width)
        return "▰"*fill + "▱"*(width-fill)

    async def update(note=""):
        pct = 0 if total_ops==0 else int(done*100/total_ops)
        bar = _progress_bar(done, total_ops)
        mm,ss = divmod(int(time.time()-started),60)
        try:
            await prog.edit(
                f"🚀 **Programación en curso**\n{bar} {pct}%\n\n"
                f"✅ Programados: {ok}\n❌ Errores: {fail}\n"
                f"⏳ Pendientes: {total_ops-done}\n⏱️ Tiempo: {mm}m {ss}s\n"
                f"{('🔎 '+note) if note else ''}"
            )
        except MessageNotModifiedError:
            pass

    mi = 0
    try:
        for slot, dpid in limited_pairs:
            mdesc = msgs[mi % len(msgs)]; mi += 1
            chat_id = mdesc["chat_id"]; mid = mdesc["message_id"]

            msg_obj = await fetch_message_with(client, chat_id, mid)
            if not msg_obj:
                fail += 1; done += 1; await update(f"ID {chat_id}:{mid} no accesible"); continue
            try:
                dest_ent = await client.get_entity(dpid)
                await client.forward_messages(
                    entity=dest_ent,
                    messages=[mid],
                    from_peer=chat_id,
                    schedule=slot
                )
                ok += 1
            except FloodWaitError as e:
                await update(f"FloodWait {e.seconds}s…"); await asyncio.sleep(e.seconds + 1)
                try:
                    dest_ent = await client.get_entity(dpid)
                    await client.forward_messages(
                        entity=dest_ent,
                        messages=[mid],
                        from_peer=chat_id,
                        schedule=slot
                    )
                    ok += 1
                except Exception:
                    fail += 1
            except Exception:
                fail += 1
            finally:
                done += 1
                local_hhmm = slot.astimezone(get_tz(u.get("timezone", "UTC"))).strftime("%H:%M")
                await update(f"{dest_view.get(dpid, dpid)} {local_hhmm}")
                await asyncio.sleep(0.05)
    finally:
        try:
            await client.disconnect()
        except Exception:
            pass

    ensure_daily_counter(u)
    u["used_today"] = u.get("used_today", 0) + ok
    if use_tmp:
        u.pop("_tmp_destinations", None)
        u.pop("_tmp_messages", None)
    save_user(uid, u)

    mm, ss = divmod(int(time.time() - started), 60)
    await prog.edit(f"✅ Listo: {ok} programados, {fail} errores, total {total_ops}. Tiempo: {mm}m {ss}s")

# =============== Captura genérica (flujos) ===============
@bot.on(events.NewMessage)
async def capture_inputs(evt):
    uid = evt.sender_id
    st = PENDING.get(uid)
    if not st:
        return

    txtlow = (evt.raw_text or "").strip().lower()
    if txtlow.startswith("/start") or txtlow.startswith("/ping"):
        return

    u = load_user(uid)

    # ----- Horario & Días -----
    if st.get("mode") == "set_hini":
        hhmm = parse_time_hhmm(evt.raw_text)
        if not hhmm:
            await evt.reply("Formato inválido. Usa HH:MM.")
            return
        hh, mm = hhmm
        he, me = u["hour_end"], u["min_end"]
        policy = plan_policy(u.get("plan_name"))
        if (hh, mm) >= (he, me):
            await evt.reply("La hora de inicio debe ser menor que la de fin.")
            return
        if not hours_allowed(policy["hours_rule"], hh, mm):
            await evt.reply("⏰ Esa hora no está permitida por tu plan.")
            return
        u["hour_start"], u["min_start"] = hh, mm
        save_user(uid, u)
        PENDING.pop(uid, None)
        await evt.reply("✅ Hora inicio actualizada.")
        return

    if st.get("mode") == "set_hfin":
        hhmm = parse_time_hhmm(evt.raw_text)
        if not hhmm:
            await evt.reply("Formato inválido. Usa HH:MM.")
            return
        hh, mm = hhmm
        hs, ms = u["hour_start"], u["min_start"]
        policy = plan_policy(u.get("plan_name"))
        if (hh, mm) <= (hs, ms):
            await evt.reply("La hora de fin debe ser mayor que la de inicio.")
            return
        if not hours_allowed(policy["hours_rule"], hh, mm):
            await evt.reply("⏰ Esa hora no está permitida por tu plan.")
            return
        u["hour_end"], u["min_end"] = hh, mm
        save_user(uid, u)
        PENDING.pop(uid, None)
        await evt.reply("✅ Hora fin actualizada.")
        return

    if st.get("mode") == "set_fprog":
        ymd = parse_date_ymd(evt.raw_text)
        if not ymd:
            await evt.reply("Formato inválido. Usa AAAA-MM-DD.")
            return
        if date.fromisoformat(ymd) < date.today():
            await evt.reply("No puedes programar en fecha pasada.")
            return
        policy = plan_policy(u.get("plan_name"))
        max_days = policy["date_days"]
        if max_days == 0 and ymd != date.today().isoformat():
            await evt.reply("📅 Tu plan sólo permite programar para **hoy**.")
            return
        if max_days > 0:
            delta = (date.fromisoformat(ymd) - date.today()).days
            if delta > max_days:
                await evt.reply(f"📅 Tu plan permite hasta {max_days} día(s) en el futuro.")
                return
        u["program_date"] = ymd
        save_user(uid, u)
        PENDING.pop(uid, None)
        await evt.reply("✅ Fecha programada actualizada.")
        return

    if st.get("mode") == "set_interval":
        v = parse_int(evt.raw_text)
        if not v or v <= 0:
            await evt.reply("Intervalo inválido (>0).")
            return
        policy = plan_policy(u.get("plan_name"))
        if v < policy["interval_min"]:
            await evt.reply(f"⏱️ El intervalo mínimo de tu plan es **{policy['interval_min']} min**.")
            return
        u["interval_min"] = v
        save_user(uid, u)
        PENDING.pop(uid, None)
        await evt.reply("✅ Intervalo actualizado.")
        return

    if st.get("mode") == "set_tz":
        tzname = (evt.raw_text or "").strip()
        try:
            pytz.timezone(tzname)
        except Exception:
            await evt.reply("Zona inválida. Ejemplos: America/Havana, America/New_York, UTC")
            return
        u["timezone"] = tzname
        save_user(uid, u)
        PENDING.pop(uid, None)
        await evt.reply(f"✅ Zona horaria actualizada a **{tzname}**.")
        return

    # --- MS: desde Canal/Grupo (paso 1: validar peer) ---
    if st.get("mode") == "ms_add_peer_step1":
        key = st.get("key")
        u = load_user(uid); u = ensure_sets_defaults(u)
        if key not in u["msg_sets"]:
            await evt.reply("❌ Conjunto no existe."); PENDING.pop(uid,None); return
        src = (evt.raw_text or "").strip()
        if src.startswith("https://t.me/"): src = src.split("/")[-1]
        if src.startswith("@"): src = src[1:]
        client,_ = await get_first_user_client(uid)
        if not client:
            await evt.reply("❌ Necesitas vincular una cuenta en **Administrar cuentas**."); return
        try:
            ent = await client.get_entity(src if not src.isdigit() else int(src))
            pid = utils.get_peer_id(ent)
            PENDING[uid] = {"mode":"ms_add_peer_step2","key":key,"peer_id":pid}
            await evt.reply(f"✅ Canal/Grupo verificado: {pretty_entity_name(ent)}\nAhora envía los **IDs** del mensaje en ese canal/grupo.")
        except Exception:
            await evt.reply("❌ No pude verificar ese canal/grupo.")
        return

    # --- MS: desde Canal/Grupo (paso 2: capturar IDs y validar) ---
    if st.get("mode") == "ms_add_peer_step2":
        key = st.get("key")
        peer_id = st.get("peer_id")
        ids = parse_id_list(evt.raw_text or "")
        if not ids:
            await evt.reply("No detecté IDs."); return
        u = load_user(uid); u = ensure_sets_defaults(u)
        if key not in u["msg_sets"]:
            await evt.reply("❌ Conjunto no existe."); PENDING.pop(uid,None); return
        client,_ = await get_first_user_client(uid)
        if not client:
            await evt.reply("❌ Vincula una cuenta para leer."); return
        # Validar que existan en ese peer
        try:
            ent = await client.get_entity(peer_id)
            msgs = await client.get_messages(ent, ids=ids)
        except Exception:
            await evt.reply("❌ Error accediendo al canal/grupo o mensajes."); return

        existing = set((x["chat_id"],x["message_id"]) for x in (u["msg_sets"][key]["items"] or []))
        ok_items = []
        details = []
        for i, mid in enumerate(ids):
            m = msgs[i] if i < len(msgs) else None
            pair = (peer_id, mid)
            if pair in existing:
                details.append(f"↩️ {peer_id}:{mid} ya estaba")
                continue
            if m is None:
                details.append(f"❌ {peer_id}:{mid} no existe")
                continue
            ok_items.append({"chat_id": peer_id, "message_id": mid})
            details.append(f"✅ {peer_id}:{mid} verificado")

        if ok_items:
            newlist = (u["msg_sets"][key]["items"] or []) + ok_items
            seen=set(); dedup=[]
            for x in newlist:
                k=(x["chat_id"], x["message_id"])
                if k in seen: continue
                seen.add(k); dedup.append(x)
            u["msg_sets"][key]["items"] = dedup
            save_user(uid,u)
        await evt.reply("📋 Resultado mensajes:\n" + "\n".join(details))
        PENDING.pop(uid,None); return

    # ----- Destinos (global legacy) -----
    if st.get("mode") == "add_dest_lines":
        lines = [l for l in (evt.raw_text or "").splitlines() if l.strip()]
        if not lines:
            await evt.reply("Necesito al menos un destino.")
            return
        client = (await get_first_user_client(uid))[0] or evt.client
        ok, skipped, bad, details = await normalize_destinations(
            client, lines, set(u.get("destinations") or [])
        )
        if ok:
            newset = list(set((u.get("destinations") or [])) | set(ok))
            u["destinations"] = newset
            save_user(uid, u)
        await evt.reply("📋 Resultado destinos:\n" + "\n".join(details))
        if client is not evt.client:
            await client.disconnect()
        PENDING.pop(uid, None)
        return

    # ----- Mensajes (Guardados, global legacy) -----
    if st.get("mode") == "add_msg_saved":
        ids = parse_id_list(evt.raw_text or "")
        if not ids:
            await evt.reply("No detecté IDs.")
            return
        client, _ = await get_first_user_client(uid)
        if not client:
            await evt.reply("❌ Necesitas vincular una cuenta en **Administrar cuentas** para leer tus Guardados.")
            return
        existing_pairs = set((x["chat_id"], x["message_id"]) for x in (u.get("messages") or []))
        ok, skipped, bad, details = await verify_saved_ids(client, ids, existing_pairs)
        if ok:
            newlist = (u.get("messages") or []) + ok
            seen, dedup = set(), []
            for x in newlist:
                k = (x["chat_id"], x["message_id"])
                if k in seen:
                    continue
                seen.add(k)
                dedup.append(x)
            u["messages"] = dedup
            save_user(uid, u)
        await evt.reply("📋 Resultado mensajes:\n" + "\n".join(details))
        await client.disconnect()
        PENDING.pop(uid, None)
        return

    # ===== Conjuntos: Destinos =====
    if st.get("mode") == "ds_new_name":
        name=(evt.raw_text or "").strip()
        if not name:
            await evt.reply("❌ Nombre inválido."); return
        u=load_user(uid)
        try:
            u,key=create_dest_set(u,name)
            save_user(uid,u)
            await evt.reply(f"✅ Conjunto creado: **{name}** (`{key}`)",parse_mode="md")
        except Exception as e:
            await evt.reply(f"❌ {e}")
        PENDING.pop(uid,None); return

    if st.get("mode") == "ds_rename":
        key=st.get("key")
        new_name=(evt.raw_text or "").strip()
        if not new_name:
            await evt.reply("❌ Nombre inválido."); return
        u=load_user(uid)
        try:
            new_key=rename_set(u,"dest",key,new_name)
            save_user(uid,u)
            await evt.reply(f"✅ Renombrado a **{new_name}** (`{new_key}`)",parse_mode="md")
        except Exception as e:
            await evt.reply(f"❌ {e}")
        PENDING.pop(uid,None); return

    if st.get("mode") == "ds_add_lines":
        key=st.get("key")
        u=load_user(uid); u=ensure_sets_defaults(u)
        if key not in u["dest_sets"]:
            await evt.reply("❌ Conjunto no existe."); PENDING.pop(uid,None); return
        lines=[l for l in (evt.raw_text or "").splitlines() if l.strip()]
        if not lines:
            await evt.reply("Necesito al menos un destino."); return
        client=(await get_first_user_client(uid))[0] or evt.client
        ok,skipped,bad,details=await normalize_destinations(client,lines,set(u["dest_sets"][key]["ids"]))
        if ok:
            newset=list(set(u["dest_sets"][key]["ids"])|set(ok))
            u["dest_sets"][key]["ids"]=newset; save_user(uid,u)
        await evt.reply("📋 Resultado destinos:\n"+"\n".join(details))
        if client is not evt.client:
            await client.disconnect()
        PENDING.pop(uid,None); return

    if st.get("mode") == "ds_remove_lines":
        key=st.get("key")
        u=load_user(uid); u=ensure_sets_defaults(u)
        if key not in u["dest_sets"]:
            await evt.reply("❌ Conjunto no existe."); PENDING.pop(uid,None); return
        client=(await get_first_user_client(uid))[0] or evt.client
        lines=[l for l in (evt.raw_text or "").splitlines() if l.strip()]
        want_remove=set()
        for line in lines:
            src=(line or "").strip()
            if src.startswith("https://t.me/"): src=src.split("/")[-1]
            if src.startswith("@"): src=src[1:]
            pid=None
            try:
                if src.isdigit():
                    try: ent=await client.get_entity(int(src))
                    except Exception: ent=None
                    if ent is None: ent=await client.get_entity(src)
                else:
                    ent=await client.get_entity(src)
                pid=utils.get_peer_id(ent)
            except Exception:
                if re.fullmatch(r"\d+",src): pid=int(src)
            if pid is not None: want_remove.add(pid)
        before=set(u["dest_sets"][key]["ids"])
        after=[pid for pid in u["dest_sets"][key]["ids"] if pid not in want_remove]
        u["dest_sets"][key]["ids"]=after; save_user(uid,u)
        removed=before-set(after)
        await evt.reply(f"🧹 Quitados: {len(removed)}")
        if client is not evt.client: await client.disconnect()
        PENDING.pop(uid,None); return

    # ===== Conjuntos: Mensajes =====
    if st.get("mode") == "ms_new_name":
        name=(evt.raw_text or "").strip()
        if not name:
            await evt.reply("❌ Nombre inválido."); return
        u=load_user(uid)
        try:
            u,key=create_msg_set(u,name)
            save_user(uid,u)
            await evt.reply(f"✅ Conjunto creado: **{name}** (`{key}`)",parse_mode="md")
        except Exception as e:
            await evt.reply(f"❌ {e}")
        PENDING.pop(uid,None); return

    if st.get("mode") == "ms_rename":
        key=st.get("key")
        new_name=(evt.raw_text or "").strip()
        if not new_name:
            await evt.reply("❌ Nombre inválido."); return
        u=load_user(uid)
        try:
            new_key=rename_set(u,"msg",key,new_name)
            save_user(uid,u)
            await evt.reply(f"✅ Renombrado a **{new_name}** (`{new_key}`)",parse_mode="md")
        except Exception as e:
            await evt.reply(f"❌ {e}")
        PENDING.pop(uid,None); return

    if st.get("mode") == "ms_add_ids":
        key=st.get("key")
        u=load_user(uid); u=ensure_sets_defaults(u)
        if key not in u["msg_sets"]:
            await evt.reply("❌ Conjunto no existe."); PENDING.pop(uid,None); return
        ids=parse_id_list(evt.raw_text or "")
        if not ids:
            await evt.reply("No detecté IDs."); return
        client,_=await get_first_user_client(uid)
        if not client:
            await evt.reply("❌ Necesitas vincular una cuenta en **Administrar cuentas** para leer tus Guardados.")
            return
        existing_pairs=set((x["chat_id"],x["message_id"]) for x in (u["msg_sets"][key]["items"] or []))
        ok,skipped,bad,details=await verify_saved_ids(client,ids,existing_pairs)
        if ok:
            newlist=(u["msg_sets"][key]["items"] or [])+ok
            seen=set(); dedup=[]
            for x in newlist:
                k=(x["chat_id"],x["message_id"])
                if k in seen: continue
                seen.add(k); dedup.append(x)
            u["msg_sets"][key]["items"]=dedup; save_user(uid,u)
        await evt.reply("📋 Resultado mensajes:\n"+"\n".join(details))
        await client.disconnect(); PENDING.pop(uid,None); return

    if st.get("mode") == "ms_remove_ids":
        key=st.get("key")
        u=load_user(uid); u=ensure_sets_defaults(u)
        if key not in u["msg_sets"]:
            await evt.reply("❌ Conjunto no existe."); PENDING.pop(uid,None); return
        ids=set(parse_id_list(evt.raw_text or ""))
        if not ids:
            await evt.reply("No detecté IDs."); return
        before=u["msg_sets"][key]["items"]
        after=[x for x in before if x["message_id"] not in ids]
        u["msg_sets"][key]["items"]=after; save_user(uid,u)
        removed=len(before)-len(after)
        await evt.reply(f"🧹 Quitados: {removed}")
        PENDING.pop(uid,None); return

    # ====== ADMIN FLOWS ======
    if st.get("mode") == "adm_view_sub":
        try:
            target_uid = int((evt.raw_text or "").strip())
        except Exception:
            await evt.reply("❌ `user_id` inválido.", parse_mode="md")
            return
        u2 = load_user(target_uid)
        plan = u2.get("plan_name") or "—"
        exp = u2.get("sub_expires") or "—"
        days = remaining_days(u2)
        blk_txt = get_block_info(u2) if is_user_blocked(u2) else "✔️ No está bloqueado"

        dcount = len(flatten_destinations_from_sets(u2))
        mcount = len(flatten_messages_from_sets(u2))

        txt = (
            f"👤 `{target_uid}`\n"
            f"⭐ Plan: **{plan}**\n"
            f"📅 Expira: **{exp}** ({days} día(s) restante(s))\n"
            f"🎯 Destinos (en conjuntos): **{dcount}**\n"
            f"💬 Mensajes (IDs en conjuntos): **{mcount}**\n"
            f"{blk_txt}"
        )
        kb = [
            [Button.inline("⬇️ CSV Destinos", f"adm_csv_dests_{target_uid}".encode()),
             Button.inline("⬇️ CSV Mensajes", f"adm_csv_msgs_{target_uid}".encode())],
            [Button.inline("⬅️ Volver", b"adm_back_admin")]
        ]
        try:
            await evt.respond(txt, buttons=kb, parse_mode="md")
        except Exception:
            await evt.reply(txt, buttons=kb, parse_mode="md")
        PENDING.pop(uid, None)
        return

    if st.get("mode") == "adm_give_sub":
        parts = re.split(r"\s+", (evt.raw_text or "").strip(), maxsplit=2)
        if len(parts) < 3:
            await evt.reply("❌ Formato inválido. Ej: `123456789 Basico 30`", parse_mode="md"); return
        try:
            target_uid = int(parts[0])
        except Exception:
            await evt.reply("❌ `user_id` inválido.", parse_mode="md"); return
        plan_key_in = parts[1]
        plan_key = _resolve_plan_key(plan_key_in)
        if not plan_key:
            await evt.reply("❌ Plan inválido. Usa: Básico / Estándar / Premium / Admin."); return
        try:
            days_ = int(parts[2])
        except Exception:
            await evt.reply("❌ `días` inválido (entero)."); return
        if days_ <= 0:
            await evt.reply("❌ `días` debe ser > 0."); return

        plans = load_plans()
        if plan_key not in plans:
            await evt.reply("❌ Plan no disponible en configuración."); return
        plan_name = plans[plan_key]["name"]

        u2 = load_user(target_uid)
        new_exp = date.today() + timedelta(days=days_)
        u2["plan_name"] = plan_name
        u2["sub_expires"] = new_exp.isoformat()
        save_user(target_uid, u2)

        await evt.reply(
            f"✅ Asignado **{plan_name}** a `{target_uid}` por **{days_}** día(s).\n"
            f"📅 Expira: **{u2['sub_expires']}**",
            parse_mode="md"
        )
        try:
            await bot.send_message(
                target_uid,
                f"🎟️ Se te ha otorgado el plan **{plan_name}** por **{days_}** día(s).\n"
                f"📅 Expira el: **{u2['sub_expires']}**"
            )
        except Exception:
            pass
        PENDING.pop(uid, None)
        return

    if st.get("mode") == "adm_block_user":
        raw = (evt.raw_text or "")
        m = re.match(r"\s*(\d+)\s*\|\s*(.+)", raw)
        if not m:
            await evt.reply("❌ Formato inválido. Usa: `user_id | motivo`", parse_mode="md"); return
        target_uid = int(m.group(1))
        reason = m.group(2).strip()
        u2 = set_user_block(target_uid, True, reason=reason, by_admin=uid)
        await evt.reply(f"✅ Usuario `{target_uid}` bloqueado.\n{get_block_info(u2)}", parse_mode="md")
        try:
            await bot.send_message(
                target_uid,
                f"🚫 Has sido **bloqueado** para usar el bot.\n"
                f"Motivo: {reason}\n"
                f"Si crees que es un error, contacta con el administrador."
            )
        except Exception:
            pass
        PENDING.pop(uid, None)
        return

    if st.get("mode") == "adm_unblock_user":
        try:
            target_uid = int((evt.raw_text or "").strip())
        except Exception:
            await evt.reply("❌ `user_id` inválido.", parse_mode="md"); return
        set_user_block(target_uid, False)
        await evt.reply(f"🔓 Usuario `{target_uid}` **desbloqueado**.", parse_mode="md")
        try:
            await bot.send_message(target_uid, "🔓 Has sido **desbloqueado**. Ya puedes usar el bot.")
        except Exception:
            pass
        PENDING.pop(uid, None)
        return

    # --- ADMIN: pedir user_id y listar cuentas con estado de sesión ---
    if st.get("mode") == "adm_user_folders_ask":
        raw = (evt.raw_text or "").strip()
        try:
            target_uid = int(raw)
        except Exception:
            await evt.reply("❌ `user_id` inválido.", parse_mode="md"); return

        u2 = load_user(target_uid)
        accs = u2.get("accounts") or []
        if not accs:
            await evt.reply("ℹ️ Ese usuario no tiene cuentas vinculadas."); 
            PENDING.pop(uid, None); 
            return

        kb = []
        deleted = []
        active = []
        for i, a in enumerate(accs[:10]):
            phone = a.get("phone")
            sess = user_session_path(target_uid, phone)
            if os.path.exists(sess):
                active.append(phone)
                kb.append([Button.inline(f"👤 {phone} (OK)", f"uf_acc_{target_uid}_{i}".encode())])
            else:
                deleted.append(phone)
                kb.append([Button.inline(f"👤 {phone} (❌ eliminada)", f"uf_acc_{target_uid}_{i}".encode())])

        lines = ["📂 **Carpetas por cuenta**"]
        if deleted:
            lines.append(f"⚠️ Cuentas con sesión eliminada: {', '.join(deleted)}")
        if not active:
            lines.append("❌ No hay sesiones activas. No se podrán leer carpetas.")

        kb.append([Button.inline("⬅️ Volver", b"adm_back_admin")])
        await evt.respond("\n".join(lines), buttons=kb, parse_mode="md")
        PENDING.pop(uid, None)
        return
    
    # ----- Login (número) -----
    if st.get("mode") == "acc_phone":
        phone = (evt.raw_text or "").strip()
        if not re.fullmatch(r"\+\d{7,15}", phone):
            await evt.reply("Formato inválido. Usa internacional, ej: +34612345678.")
            return
        sess = user_session_path(uid, phone)
        uc = TelegramClient(sess, API_ID, API_HASH)
        try:
            await uc.connect()
            sent = await uc.send_code_request(phone)
            PENDING[uid] = {"mode": "acc_code", "phone": phone, "phone_code_hash": sent.phone_code_hash}
            await evt.reply("📩 Te envié un código de Telegram. Escríbelo aquí (puedes dejar espacios entre dígitos).")
        except RPCError as e:
            await evt.reply(f"❌ Error enviando código: {e.__class__.__name__}")
            PENDING.pop(uid, None)
        finally:
            try:
                await uc.disconnect()
            except Exception:
                pass
        return

    # ----- Login (código) -----
    if st.get("mode") == "acc_code":
        raw = (evt.raw_text or "")
        code = "".join(re.findall(r"\d", raw))
        if not code:
            await evt.reply("Código inválido.")
            return
        phone = st.get("phone")
        phash = st.get("phone_code_hash")
        sess = user_session_path(uid, phone)
        uc = TelegramClient(sess, API_ID, API_HASH)
        try:
            await uc.connect()
            try:
                await uc.sign_in(phone=phone, code=code, phone_code_hash=phash)
                me = await uc.get_me()
                u.setdefault("accounts", []).append({"phone": phone, "status": "approved", "user_id": me.id})
                save_user(uid, u)
                nm = me.first_name or ("@" + (me.username or "")) or str(me.id)
                await evt.reply(f"✅ Registro completado. Cuenta añadida: {nm}")
                PENDING.pop(uid, None)
            except SessionPasswordNeededError:
                PENDING[uid] = {"mode": "acc_2fa", "phone": phone}
                await evt.reply("🔑 Tu cuenta tiene verificación en dos pasos. Ingresa tu contraseña:")
            except PhoneCodeInvalidError:
                await evt.reply("❌ Código inválido. Intenta de nuevo.")
            except PhoneCodeExpiredError:
                await evt.reply("❌ Código expirado. Repite desde *Administrar cuentas*.")
        except RPCError as e:
            await evt.reply(f"❌ Error de inicio: {e.__class__.__name__}")
        finally:
            try:
                await uc.disconnect()
            except Exception:
                pass
        return

    # ----- Login (2FA) -----
    if st.get("mode") == "acc_2fa":
        pwd = (evt.raw_text or "")
        phone = st.get("phone")
        sess = user_session_path(uid, phone)
        uc = TelegramClient(sess, API_ID, API_HASH)
        try:
            await uc.connect()
            await uc.sign_in(password=pwd)
            me = await uc.get_me()
            u.setdefault("accounts", []).append({"phone": phone, "status": "approved", "user_id": me.id})
            save_user(uid, u)
            nm = me.first_name or ("@" + (me.username or "")) or str(me.id)
            await evt.reply(f"✅ Registro completado. Cuenta añadida: {nm}")
            PENDING.pop(uid, None)
        except RPCError as e:
            await evt.reply(f"❌ Contraseña 2FA incorrecta o error: {e.__class__.__name__}")
        finally:
            try:
                await uc.disconnect()
            except Exception:
                pass
        return

    # ----- TZ por cuenta (entrada manual) -----
    if st.get("mode") == "set_tz_acc_manual":
        tzname = (evt.raw_text or "").strip()
        try:
            pytz.timezone(tzname)
        except Exception:
            await evt.reply("Zona inválida. Ejemplos: America/Havana, America/New_York, UTC")
            return
        idx = st.get("acc_index")
        accs = u.get("accounts") or []
        if not (isinstance(idx, int) and 0 <= idx < len(accs)):
            await evt.reply("Índice inválido.")
            PENDING.pop(uid, None)
            return
        u.setdefault("account_tz", {})
        uid_acc = str(accs[idx].get("user_id"))
        u["account_tz"][uid_acc] = tzname
        save_user(uid, u)
        PENDING.pop(uid, None)
        await evt.reply(t(u, "TZ_SET_ACC_OK", tz=tzname))
        return
    # --- Carpetas & chats por usuario ---
    if st.get("mode") == "adm_user_folders":
        raw = (evt.raw_text or "").strip()
        try:
            target_uid = int(raw)
        except Exception:
            await evt.reply("❌ `user_id` inválido.", parse_mode="md"); return

        client,_ = await get_first_user_client(target_uid)
        if not client:
            await evt.reply("❌ Ese usuario no tiene ninguna cuenta vinculada o autorizada.")
            PENDING.pop(uid, None); return

        text_out = []
        csv_rows = []
        try:
        # 1) Intentar API de filtros (carpetas)
            dlg_filters = None
            try:
                resp = await client(functions.messages.GetDialogFiltersRequest())
                # Telethon devuelve un objeto DialogFilters con la propiedad .filters
                dlg_filters = getattr(resp, "filters", None)
            except Exception:
                dlg_filters = None

            if isinstance(dlg_filters, list) and dlg_filters:
                # Recorremos cada carpeta definida por el usuario
                for f in dlg_filters:
                    title = getattr(f, "title", f"Carpeta {getattr(f, 'id', '?')}")
                    pins = getattr(f, "pinned_peers", []) or []
                    includes = getattr(f, "include_peers", []) or []

                    dumped = []
                    for p in pins + includes:
                        try:
                            ent = await client.get_entity(p)
                            name = pretty_entity_name(ent)
                            pid = utils.get_peer_id(ent)
                            dumped.append((pid, name))
                        except Exception:
                            pass

                    text_out.append(f"📂 **{title}**")
                    if not dumped:
                        text_out.append("  — (vacía)")
                    else:
                        for pid, name in dumped:
                            text_out.append(f"  • {name} (`{pid}`)")
                            csv_rows.append([title, pid, name])

            else:
                # 2) Fallback: agrupar por folder_id a partir de los diálogos
                dialogs = await client.get_dialogs()
                buckets = {}
                for d in dialogs:
                    fid = getattr(d, "folder_id", None)
                    if fid is None:
                        continue
                    buckets.setdefault(f"Carpeta {fid}", []).append(
                        (utils.get_peer_id(d.entity), pretty_entity_name(d.entity))
                    )

                if not buckets:
                    text_out.append("ℹ️ Este usuario no tiene carpetas definidas o el cliente no las expone.")
                else:
                    for title, items in buckets.items():
                        text_out.append(f"📂 **{title}**")
                        for pid, name in items:
                            text_out.append(f"  • {name} (`{pid}`)")
                            csv_rows.append([title, pid, name])
        finally:
            try:
                await client.disconnect()
            except Exception:
                pass

        msg = "📂 **Carpetas & chats**\n\n" + "\n".join(text_out[:400])
        await evt.reply(msg, parse_mode="md")

        if csv_rows:
            await send_csv(uid, f"carpetas_{target_uid}.csv", ["folder","peer_id","name"], csv_rows)

        PENDING.pop(uid, None)
        return

async def _fetch_folder_items(client, fid: int, max_count: int = 200):
    """
    Devuelve [(peer_id, nombre_bonito), ...] de la carpeta fid usando messages.GetDialogs.
    """
    # Primer “page”; para tu UI de 10 en 10 es suficiente.
    res = await client(functions.messages.GetDialogsRequest(
        folder_id=fid,
        offset_date=0,
        offset_id=0,
        offset_peer=types.InputPeerEmpty(),
        limit=min(200, max_count),
        hash=0
    ))
    items = []
    # res.dialogs contiene los peers de la carpeta
    for dlg in getattr(res, "dialogs", []) or []:
        pid = utils.get_peer_id(dlg.peer)
        try:
            ent = await client.get_entity(pid)
            name = pretty_entity_name(ent)
        except Exception:
            name = str(pid)
        items.append((pid, name))
    return items

def _parse_uf_fold(data: str):
    m = re.fullmatch(r"uf_fold_(\d+)_(\d+)_(\d+)_(\d+)", data)
    if not m:
        return None
    uid = int(m.group(1)); acc = int(m.group(2)); fid = int(m.group(3)); page = int(m.group(4))
    return uid, acc, fid, page

def _safe_text(x):
    # Convierte TextWithEntities a str normal
    try:
        if isinstance(x, types.TextWithEntities):
            return x.text
    except Exception:
        pass
    return str(x) if x is not None else ""

def _is_broadcast_channel(ent):
    # Canal de difusión (no megagrupo)
    try:
        return bool(getattr(ent, "broadcast", False)) and not getattr(ent, "megagroup", False)
    except Exception:
        # Telethon modernos: Channel(megagroup=True/False)
        return bool(getattr(ent, "megagroup", False) is False and getattr(ent, "broadcast", False))

def _classify_dialog(d):
    """
    Devuelve un dict con banderas útiles para aplicar filtros:
    is_user, is_contact, is_bot, is_group, is_broadcast, unread_count, folder_id, is_muted
    """
    ent = d.entity
    is_user = hasattr(ent, "first_name") or isinstance(ent, types.User)
    is_group = bool(getattr(d, "is_group", False))
    is_chan = bool(getattr(d, "is_channel", False))

    is_bot = False
    is_contact = False
    is_broadcast = False

    if is_user:
        is_bot = bool(getattr(ent, "bot", False))
        is_contact = bool(getattr(ent, "contact", False))
    if is_group:
        # grupos y megagrupos entran en 'groups'
        pass
    if is_chan:
        is_broadcast = _is_broadcast_channel(ent)

    # no todos los Telethon tienen .is_muted; intentamos derivarlo
    is_muted = bool(getattr(d, "is_muted", False))
    if not is_muted:
        ns = getattr(d, "notify_settings", None)
        try:
            if ns and getattr(ns, "mute_until", 0):
                is_muted = True
        except Exception:
            pass

    return {
        "is_user": is_user,
        "is_contact": is_contact,
        "is_bot": is_bot,
        "is_group": is_group,
        "is_broadcast": is_broadcast,
        "unread": int(getattr(d, "unread_count", 0) or 0),
        "folder_id": getattr(d, "folder_id", None),
        "is_muted": is_muted,
    }

def _peer_id_from_inputpeer(p):
    try:
        return utils.get_peer_id(p)
    except Exception:
        # últimos recursos
        for attr in ("user_id", "chat_id", "channel_id"):
            if hasattr(p, attr):
                return int(getattr(p, attr))
        return None

def _build_last_ts_map(dialogs):
    """Mapa peer_id -> fecha/hora del último mensaje (para ordenar)."""
    m = {}
    for d in dialogs:
        ts = getattr(d, "date", None)
        if ts is None:
            msg = getattr(d, "message", None)
            if msg is not None:
                ts = getattr(msg, "date", None)
        if ts is None:
            ts = datetime.min
        try:
            pid = utils.get_peer_id(d.entity)
            m[pid] = ts
        except Exception:
            pass
    return m

def _apply_filter_to_dialogs(filt, dialogs, last_ts_map=None):
    """
    Aplica el DialogFilter a 'dialogs' y devuelve [(peer_id, name)], ordenado
    de más reciente a más antiguo usando last_ts_map.
    """
    def _peer_id_from_inputpeer(p):
        try:
            return utils.get_peer_id(p)
        except Exception:
            for attr in ("user_id", "chat_id", "channel_id"):
                if hasattr(p, attr):
                    return int(getattr(p, attr))
            return None

    inc_ids = set()
    exc_ids = set()
    for p in (getattr(filt, "include_peers", None) or []):
        pid = _peer_id_from_inputpeer(p);  pid and inc_ids.add(pid)
    for p in (getattr(filt, "exclude_peers", None) or []):
        pid = _peer_id_from_inputpeer(p);  pid and exc_ids.add(pid)

    want_contacts     = bool(getattr(filt, "contacts", False))
    want_non_contacts = bool(getattr(filt, "non_contacts", False))
    want_groups       = bool(getattr(filt, "groups", False))
    want_broadcasts   = bool(getattr(filt, "broadcasts", False) or getattr(filt, "channels", False))
    want_bots         = bool(getattr(filt, "bots", False))
    exclude_muted     = bool(getattr(filt, "exclude_muted", False))
    exclude_read      = bool(getattr(filt, "exclude_read", False))
    exclude_archived  = bool(getattr(filt, "exclude_archived", False))
    any_flag = any([want_contacts, want_non_contacts, want_groups, want_broadcasts, want_bots])

    def _classify_dialog(d):
        ent = d.entity
        is_user = hasattr(ent, "first_name") or isinstance(ent, types.User)
        is_group = bool(getattr(d, "is_group", False))
        is_chan  = bool(getattr(d, "is_channel", False))
        is_bot = bool(getattr(ent, "bot", False)) if is_user else False
        is_contact = bool(getattr(ent, "contact", False)) if is_user else False
        is_broadcast = False
        if is_chan:
            # canal de difusión (no megagrupo)
            is_broadcast = bool(getattr(ent, "broadcast", False)) and not getattr(ent, "megagroup", False)
        is_muted = bool(getattr(d, "is_muted", False))
        if not is_muted:
            ns = getattr(d, "notify_settings", None)
            if ns and getattr(ns, "mute_until", 0):
                is_muted = True
        return {
            "is_user": is_user, "is_contact": is_contact, "is_bot": is_bot,
            "is_group": is_group, "is_broadcast": is_broadcast,
            "unread": int(getattr(d, "unread_count", 0) or 0),
            "folder_id": getattr(d, "folder_id", None), "is_muted": is_muted,
        }

    items = []
    for d in dialogs:
        pid = utils.get_peer_id(d.entity)
        if pid in exc_ids:
            continue
        info = _classify_dialog(d)
        if exclude_archived and info["folder_id"] == 1:  # archivados
            continue
        if exclude_muted and info["is_muted"]:
            continue
        if exclude_read and info["unread"] == 0:
            continue

        match_flag = False
        if any_flag:
            if info["is_user"]:
                if want_bots and info["is_bot"]:
                    match_flag = True
                if want_contacts and info["is_contact"]:
                    match_flag = True
                if want_non_contacts and not info["is_contact"] and not info["is_bot"]:
                    match_flag = True
            if want_groups and info["is_group"]:
                match_flag = True
            if want_broadcasts and info["is_broadcast"]:
                match_flag = True

        if pid in inc_ids:
            match_flag = True

        if match_flag:
            try:
                name = pretty_entity_name(d.entity)
            except Exception:
                name = str(pid)
            items.append((pid, name))

    # ORDENAR por último timestamp (desc)
    if last_ts_map is not None:
        items.sort(key=lambda x: last_ts_map.get(x[0], datetime.min), reverse=True)
    return items

async def _fetch_archived_items(client, max_count=200):
    res = await client(functions.messages.GetDialogsRequest(
        folder_id=1,  # ARCHIVADOS
        offset_date=0,
        offset_id=0,
        offset_peer=types.InputPeerEmpty(),
        limit=min(200, max_count),
        hash=0
    ))
    out = []
    for dlg in getattr(res, "dialogs", []) or []:
        pid = utils.get_peer_id(dlg.peer)
        try:
            ent = await client.get_entity(pid)
            name = pretty_entity_name(ent)
        except Exception:
            name = str(pid)
        out.append((pid, name))
    return out

from telethon.tl import functions
from datetime import datetime

def _safe_title(x):
    # Convierte TextWithEntities a texto plano si viene así
    try:
        t = getattr(x, "text", None)
        return t if t is not None else str(x)
    except Exception:
        return str(x)

@bot.on(events.CallbackQuery(pattern=rb"^uf_acc_\d+_\d+$"))
async def uf_acc_pick(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True); return
    try:
        await cq_ack(event)
    except Exception:
        pass

    await event.edit("📁 Cargando carpetas…")

    parts = event.data.decode().split("_")
    target_uid = int(parts[2]); acc_index = int(parts[3])

    u2 = load_user(target_uid)
    accs = u2.get("accounts") or []
    if not (0 <= acc_index < len(accs)):
        await event.answer("Índice inválido.", alert=True); return

    phone = accs[acc_index].get("phone")
    sess = user_session_path(target_uid, phone)
    if not os.path.exists(sess):
        await event.answer("Esta cuenta tiene la sesión eliminada.", alert=True); return

    client = TelegramClient(sess, API_ID, API_HASH)
    folders = []
    last_ts_map = {}  # peer_id -> datetime de última actividad
    try:
        await client.connect()

        # 1) Obtener filtros (carpetas personalizadas del usuario)
        try:
            resp = await client(functions.messages.GetDialogFiltersRequest())
            flist = list(getattr(resp, "filters", []) or [])
        except Exception:
            flist = []

       # 2) Cargar diálogos (principal + intentar archivados)
        all_dlgs = []
        # principal
        async for d in client.iter_dialogs(limit=3000):
            all_dlgs.append(d)
        # intentar archivados (algunas versiones aceptan folder=1)
        try:
            async for d in client.iter_dialogs(limit=3000, folder=1):
                all_dlgs.append(d)
        except TypeError:
            # fallback: sin folder param; no pasa nada
            pass

        # ... ya tienes all_dlgs (principal + archivados)
        last_ts_map = _build_last_ts_map(all_dlgs)

        folders = []
        if flist:
            for f in flist:
                fid = getattr(f, "id", None)
                if fid is None:
                    continue
                title = _safe_text(getattr(f, "title", None)) or f"Carpeta {fid}"
                items = _apply_filter_to_dialogs(f, all_dlgs, last_ts_map=last_ts_map)
                folders.append({"fid": fid, "title": title, "items": items})
        else:
            try:
                arch = await _fetch_archived_items(client, max_count=200)
            except Exception:
                arch = []
            if arch:
                # ordenar también los archivados
                arch = sorted(arch, key=lambda x: last_ts_map.get(x[0], datetime.min), reverse=True)
                folders.append({"fid": 1, "title": "Archivados", "items": arch})
    finally:
        try:
            await client.disconnect()
        except Exception:
            pass

    if not folders:
        await safe_edit(event, "ℹ️ No se encontraron **carpetas** visibles para esa cuenta.", buttons=[[Button.inline("⬅️ Volver", b"adm_back_admin")]])
        return

    # Guardar estado para navegar (importante: incluimos last_ts_map)
    PENDING[event.sender_id] = {
        "mode": "uf_state",
        "target_uid": target_uid,
        "acc_index": acc_index,
        "folders": folders,
        "last_ts_map": last_ts_map
    }

    # Listado de carpetas
    kb = []
    for f in folders[:12]:
        kb.append([Button.inline(f"📂 {f['title']} ({len(f['items'])})",
                                 f"uf_fold_{target_uid}_{acc_index}_{f['fid']}_0".encode())])
    kb.append([Button.inline("⬅️ Volver", b"adm_back_admin")])
    await safe_edit(event, "Elige una **carpeta**:", buttons=kb, parse_mode="md")

from datetime import datetime

@bot.on(events.CallbackQuery(pattern=rb"^uf_fold_\d+_\d+_\d+_\d+$"))
async def uf_fold_page(event):
    try:
        await cq_ack(event)
    except Exception:
        pass

    parts = event.data.decode().split("_")
    # formato: uf_fold_{target_uid}_{acc_index}_{fid}_{page}
    if len(parts) != 6:
        await event.answer("Formato inválido.", alert=True); return

    target_uid = int(parts[2])
    acc_index  = int(parts[3])
    fid        = int(parts[4])
    page       = int(parts[5])

    st = PENDING.get(event.sender_id) or {}
    if st.get("mode") != "uf_state" \
       or st.get("target_uid") != target_uid \
       or st.get("acc_index")  != acc_index \
       or not st.get("folders"):
        await event.answer("No hay estado de carpetas. Regresa y vuelve a entrar.", alert=True)
        return

    folders = st["folders"]
    # buscar la carpeta pedida
    folder = next((f for f in folders if f["fid"] == fid), None)
    if not folder:
        await event.answer("Carpeta no encontrada.", alert=True); return

    items = list(folder.get("items") or [])

    # 🔒 Re-orden defensivo por última actividad si tenemos el mapa
    last_ts_map = st.get("last_ts_map") or {}
    if last_ts_map:
        items.sort(key=lambda x: last_ts_map.get(x[0], datetime.min), reverse=True)

    PAGE_SZ = 10
    start = page * PAGE_SZ
    end   = start + PAGE_SZ
    page_items = items[start:end]

    # Teclado con 10 resultados + navegación
    kb = []
    # Numeración bonita (absoluta: 1..N) — esto NO cambia el orden
    for idx, (peer_id, name) in enumerate(page_items, start=1):
        nlabel = f"{start + idx}) {name}"
        kb.append([
            Button.inline(nlabel, b"noop"),
            Button.inline(str(idx), f"uf_exp_{target_uid}_{acc_index}_{fid}_{page}_{peer_id}".encode())
        ])

    # navegación páginas
    nav = []
    if page > 0:
        nav.append(Button.inline("◀️ Prev", f"uf_fold_{target_uid}_{acc_index}_{fid}_{page-1}".encode()))
    if end < len(items):
        nav.append(Button.inline("Next ▶️", f"uf_fold_{target_uid}_{acc_index}_{fid}_{page+1}".encode()))
    if nav:
        kb.append(nav)

    # volver a carpetas
    kb.append([Button.inline("⬅️ Volver a carpetas", f"uf_back_{target_uid}_{acc_index}".encode())])

    # Título
    title = folder.get("title") or f"Carpeta {fid}"
    total = len(items)
    txt = f"📂 **{title}** — {total} chat(s)\nPágina {page+1}"
    await event.edit(txt, buttons=kb, parse_mode="md")
    
@bot.on(events.CallbackQuery(pattern=rb"^uf_back_\d+_\d+$"))
async def uf_back_to_folders(event):
    try:
        await cq_ack(event)
    except Exception:
        pass

    parts = event.data.decode().split("_")
    # formato: uf_back_{target_uid}_{acc_index}
    if len(parts) != 4:
        await event.answer("Formato inválido.", alert=True); return

    target_uid = int(parts[2])
    acc_index  = int(parts[3])

    st = PENDING.get(event.sender_id) or {}
    # Esperamos que uf_acc_pick haya guardado esto:
    # {"mode":"uf_state","target_uid":..., "acc_index":..., "folders":[...], "last_ts_map":{...}}
    if st.get("mode") != "uf_state" \
       or st.get("target_uid") != target_uid \
       or st.get("acc_index")  != acc_index \
       or not st.get("folders"):
        # Estado no disponible -> recarga rápida llamando de nuevo a la selección de cuenta
        await event.answer("Recargando carpetas…", alert=False)
        # Reutiliza tu flujo original de carga:
        # Puedes llamar al mismo código que usas en uf_acc_pick pero en función auxiliar.
        # Si no tienes esa auxiliar, la forma simple es pedirle otra vez al admin
        # que re-entre por el menú anterior:
        await event.edit("Vuelve a elegir la cuenta para ver carpetas.", buttons=[
            [Button.inline("⬅️ Volver", b"adm_back_admin")]
        ])
        return

    folders = st["folders"]

    kb = []
    for f in folders[:12]:
        fid   = f["fid"]
        title = f["title"]
        count = len(f.get("items") or [])
        kb.append([Button.inline(f"📂 {title} ({count})", f"uf_fold_{target_uid}_{acc_index}_{fid}_0".encode())])

    kb.append([Button.inline("⬅️ Volver", b"adm_back_admin")])
    await event.edit("Elige una **carpeta**:", buttons=kb, parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^uf_exp_\d+_\d+_\d+_\d+_-?\d+$"))
async def uf_export_chat(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True); return
    try:
        await cq_ack(event)
    except Exception:
        pass

    parts = event.data.decode().split("_")
    # uf_exp_{target_uid}_{acc_index}_{fid}_{page}_{peer_id}
    if len(parts) != 7:
        await event.answer("Formato inválido.", alert=True); return

    target_uid = int(parts[2]); acc_index = int(parts[3])
    # fid  = int(parts[4]); page = int(parts[5])  # no imprescindibles aquí
    peer_id   = int(parts[6])

    u2 = load_user(target_uid)
    accs = u2.get("accounts") or []
    if not (0 <= acc_index < len(accs)):
        await event.answer("Índice inválido.", alert=True); return

    phone = accs[acc_index].get("phone")
    sess = user_session_path(target_uid, phone)
    if not os.path.exists(sess):
        await event.answer("Esa cuenta no tiene sesión.", alert=True); return

    await event.edit("⏳ Exportando HTML + multimedia…")

    client = TelegramClient(sess, API_ID, API_HASH)
    try:
        await client.connect()
        me = await client.get_me()
        me_id = utils.get_peer_id(me)

        # TZ: por cuenta > global
        tzname = None
        if u2.get("account_tz"):
            uid_acc = str(accs[acc_index].get("user_id"))
            tzname = u2["account_tz"].get(uid_acc)
        if not tzname:
            tzname = u2.get("timezone","America/Havana")

        # Rutas de salida
        out_dir = os.path.join(DATA, "exports", f"{target_uid}_{peer_id}")
        path = await export_chat_html(client, peer_id, out_dir, tzname="America/Havana", limit=3000)
        await bot.send_message(ADMIN_ID, f"✅ Export listo: {path}")
        zip_path  = _zip_dir(out_dir, out_dir)  # crea base_dir.zip

    finally:
        try:
            await client.disconnect()
        except Exception:
            pass

    # Te envío el ZIP por el bot (a ti, admin)
    caption = f"📦 Exportación HTML + media\nUsuario: `{target_uid}`\nPeer: `{peer_id}`"
    try:
        await bot.send_file(event.sender_id, zip_path, caption=caption)
    except Exception as e:
        await event.edit(f"Exportación creada pero no pude adjuntar el archivo.\nRuta: `{zip_path}`\nError: {e}", parse_mode="md")
        return

    # Volver a la misma página (manteniendo navegación)
    await event.answer("Exportación lista.", alert=False)

PAGE_SIZE = 10  # el mismo que usas en uf_fold_page

async def render_folder_list(event, target_uid: int, acc_index: int):
    admin_uid = event.sender_id
    st = PENDING.get(admin_uid) or {}
    folders = st.get("folders") or []

    # Comprueba si la sesión de esa cuenta existe (mostrar aviso)
    u_target = load_user(target_uid)
    accs = u_target.get("accounts") or []
    sess_missing = False
    if not (0 <= acc_index < len(accs)):
        sess_missing = True
    else:
        phone = accs[acc_index].get("phone")
        sess_path = user_session_path(target_uid, phone)
        if not os.path.exists(sess_path):
            sess_missing = True

    lines = []
    if sess_missing:
        lines.append("⚠️ **La sesión de esa cuenta no está disponible (eliminada o inválida).**\n")

    if not folders:
        lines.append("— Sin carpetas —")
    else:
        lines.append("📁 **Carpetas** (toca una para ver sus chats)")
        for i, f in enumerate(folders[:25]):  # muestra hasta 25 carpetas
            title = as_plain_text(f.get("title")) or f"Carpeta {i}"
            count = len(f.get("items") or [])
            lines.append(f"• {i+1}) {title} — {count} chats")

    kb = []
    # Botones de carpetas
    for i, f in enumerate(folders[:25]):
        title = as_plain_text(f.get("title")) or f"Carpeta {i}"
        kb.append([Button.inline(f"📂 {title}", f"uf_fold_{target_uid}_{acc_index}_{i}_0".encode())])

    kb.append([Button.inline("⬅️ Admin", b"adm_back_admin")])
    await safe_edit(event, "\n".join(lines), buttons=kb, parse_mode="md")

# =============== Menú de idioma ===============
@bot.on(events.CallbackQuery(pattern=rb"^menu_lang$"))
@plan_guard
async def menu_lang(event):
    u = load_user(event.sender_id)
    lang = (u.get("lang") or "es").lower()
    txt = t(u, "LANG_MENU_TITLE", code=lang.upper())
    kb = [
        [Button.inline(t(u,"LANG_ES"), b"lang_es"), Button.inline(t(u,"LANG_EN"), b"lang_en")],
        [Button.inline(t(u,"LANG_RU"), b"lang_ru"), Button.inline(t(u,"LANG_PT"), b"lang_pt")],
        [Button.inline(t(u,"BTN_BACK"), b"back_panel")],
    ]
    await event.edit(txt, buttons=kb, parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^lang_(es|en|ru|pt)$"))
@plan_guard
async def set_lang(event):
    code = event.data.decode().split("_",1)[1]
    u = load_user(event.sender_id)
    u["lang"] = code
    save_user(event.sender_id, u)
    # Tras cambiar idioma, re-renderiza el panel principal en el nuevo idioma
    texto, kb = render_panel(u)
    try:
        await event.edit(t(u,"LANG_CHANGED", code=code.upper()) + "\n\n" + texto, buttons=kb, parse_mode="md")
    except Exception:
        await event.respond(t(u,"LANG_CHANGED", code=code.upper()))
        await event.respond(texto, buttons=kb, parse_mode="md")

# =============== Administrar cuentas ===============
@bot.on(events.CallbackQuery(pattern=b"menu_acc"))
@plan_guard
async def menu_acc(event):
    u = load_user(event.sender_id)
    accs = u.get("accounts") or []
    cap = plan_policy(u.get("plan_name")).get("profiles", 0)
    listado = ("\n".join([f"• {i+1}) {a.get('phone')} (ID {a.get('user_id','?')})" for i, a in enumerate(accs)]) if accs else t(u,"NO_ACCOUNTS"))
    texto = t(u, "ACC_MGMT_TITLE", added=len(accs), cap=cap, list=listado)
    can_add = len(accs) < cap
    kb = []
    if can_add:
        kb.append([Button.inline(t(u,"BTN_ACC_ADD"), b"acc_add")])
    kb.append([Button.inline(t(u,"BTN_ACC_DEL"), b"acc_del")])
    kb.append([Button.inline(t(u,"BTN_BACK"), b"back_panel")])
    await event.edit(texto, buttons=kb)

@bot.on(events.CallbackQuery(pattern=b"acc_add"))
@plan_guard
async def acc_add(event):
    uid = event.sender_id
    u = load_user(uid)
    cap = plan_policy(u.get("plan_name")).get("profiles", 0)
    if len(u.get("accounts") or []) >= cap:
        await event.answer("Has alcanzado el límite de perfiles para tu plan.", alert=True)
        return
    PENDING[uid] = {"mode": "acc_phone"}
    await event.respond("📱 Envíame tu número en formato internacional (ej: +34612345678).")

@bot.on(events.CallbackQuery(pattern=b"acc_del"))
@plan_guard
async def acc_del(event):
    uid = event.sender_id
    u = load_user(uid)
    accs = u.get("accounts") or []
    if not accs:
        await event.answer("No tienes cuentas para eliminar.", alert=True)
        return
    kb = []
    row = []
    for i, a in enumerate(accs):
        lab = f"🗑 {a.get('phone')}"
        row.append(Button.inline(lab, f"acc_del_pick_{i}".encode()))
        if len(row) == 2:
            kb.append(row)
            row = []
    if row:
        kb.append(row)
    kb.append([Button.inline(t(u,"BTN_BACK"), b"menu_acc")])
    await safe_edit(event, t(u, "DEL_PICK_ACCOUNT"), buttons=kb)

@bot.on(events.CallbackQuery(pattern=b"acc_del_pick_"))
@plan_guard
async def acc_del_pick(event):
    uid = event.sender_id
    idx = int(event.data.decode().split("_")[-1])
    u = load_user(uid)
    accs = u.get("accounts") or []
    if 0 <= idx < len(accs):
        phone = accs[idx].get("phone")
        sess = user_session_path(uid, phone)
        try:
            if os.path.exists(sess):
                os.remove(sess)
        except Exception:
            pass
        accs.pop(idx)
        u["accounts"] = accs
        save_user(uid, u)
        await safe_edit(event, t(u, "ACC_REMOVED_OK", phone=phone), buttons=[[Button.inline(t(u,"BTN_BACK"), b"menu_acc")]])
    else:
        await event.answer("Índice inválido.", alert=True)

# =============== /ping ===============
@bot.on(events.NewMessage(pattern=r"(?i)^/(?:ping)(?:@[\w_]+)?$"))
async def cmd_ping(evt):
    await evt.respond("🏓 Pong")

# =============== Admin callbacks ===============
@bot.on(events.CallbackQuery(pattern=rb"^adm_view_sub$"))
async def adm_view_sub(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True); return
    await event.answer()
    PENDING[event.sender_id] = {"mode": "adm_view_sub"}
    await event.respond("📝 Envía el `user_id` del usuario a consultar.", parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^adm_give_sub$"))
async def adm_give_sub(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True); return
    await event.answer()
    PENDING[event.sender_id] = {"mode": "adm_give_sub"}
    await event.respond(
        "📝 Envía en **una línea**:  `user_id  plan  días`\n"
        "Ej: `123456789 Basico 30`",
        parse_mode="md"
    )

@bot.on(events.CallbackQuery(pattern=rb"^adm_block_user$"))
async def adm_block_user(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True); return
    await event.answer()
    PENDING[event.sender_id] = {"mode": "adm_block_user"}
    await event.respond(
        "📝 Envía:  `user_id | motivo del bloqueo`\n"
        "Ej: `123456789 | abuso de la API`",
        parse_mode="md"
    )

@bot.on(events.CallbackQuery(pattern=rb"^adm_list_blocked$"))
async def adm_list_blocked(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True); return
    await event.answer()

    blocked = []
    try:
        for fname in os.listdir(DATA):
            if not fname.endswith(".json"):
                continue
            uid_str = fname[:-5]
            if not uid_str.isdigit():
                continue
            uid = int(uid_str)
            u = load_user(uid)
            if is_user_blocked(u):
                blk = u.get("blocked") or {}
                blocked.append((uid, blk.get("since") or "—", blk.get("reason") or "Sin motivo"))
    except Exception:
        pass

    if not blocked:
        await event.edit("✅ No hay usuarios bloqueados.", buttons=[[Button.inline("⬅️ Volver", b"adm_back_admin")]])
        return

    lines = [f"• `{uid}` | desde {since} | {reason}" for uid, since, reason in blocked[:30]]
    extra = "" if len(blocked) <= 30 else f"\n… y {len(blocked)-30} más."
    txt = "📋 **Usuarios bloqueados**\n\n" + "\n".join(lines) + extra
    await event.edit(txt, buttons=[[Button.inline("⬅️ Volver", b"adm_back_admin")]], parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^adm_unblock_user$"))
async def adm_unblock_user(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True); return
    await event.answer()
    PENDING[event.sender_id] = {"mode": "adm_unblock_user"}
    await event.respond("📝 Envía el `user_id` a **desbloquear**.", parse_mode="md")

@bot.on(events.CallbackQuery(pattern=rb"^adm_csv_dests_\d+$"))
async def adm_csv_dests(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True); return
    await event.answer()
    target_uid = int(event.data.decode().split("_")[-1])
    u2 = load_user(target_uid)
    dest_ids = flatten_destinations_from_sets(u2)

    # opcional: intentar nombres bonitos usando la 1ra cuenta del usuario
    names = {}
    client,_ = await get_first_user_client(target_uid)
    if client:
        names = await resolve_names_map(client, dest_ids)
        await client.disconnect()

    rows = []
    for pid in dest_ids:
        rows.append([pid, names.get(pid, str(pid))])

    await send_csv(event.sender_id, f"destinos_{target_uid}.csv", ["peer_id","name"], rows)
    await event.answer("CSV enviado.", alert=False)


@bot.on(events.CallbackQuery(pattern=rb"^adm_csv_msgs_\d+$"))
async def adm_csv_msgs(event):
    if str(event.sender_id) != str(ADMIN_ID):
        await event.answer("Solo admin.", alert=True); return
    await event.answer()
    target_uid = int(event.data.decode().split("_")[-1])
    u2 = load_user(target_uid)
    pairs = flatten_messages_from_sets(u2)

    # intentar resolver nombres del chat_id
    chat_ids = sorted({c for c,_ in pairs})
    names = {}
    client,_ = await get_first_user_client(target_uid)
    if client:
        names = await resolve_names_map(client, chat_ids)
        await client.disconnect()

    rows = []
    for chat_id, mid in pairs:
        rows.append([chat_id, names.get(chat_id, str(chat_id)), mid])

    await send_csv(event.sender_id, f"mensajes_{target_uid}.csv", ["chat_id","chat_name","message_id"], rows)
    await event.answer("CSV enviado.", alert=False)

# =============== MAIN ===============
def main():
    print("🚀 Bot escuchando…")
    bot.run_until_disconnected()

if __name__ == "__main__":
    main()