autoficher/app/bot.py

"""Interfaz de Telegram: comandos, teclados inline y killswitch.

Solo atiende al ``chat_id`` configurado. Cualquier otro chat se ignora en silencio.
"""
from __future__ import annotations

import asyncio
import logging
from datetime import date, datetime, timedelta

from telegram import (BotCommand, BotCommandScopeChat, InlineKeyboardButton,
                      InlineKeyboardMarkup, Update)
from telegram.constants import ParseMode
from telegram.ext import Application, CallbackQueryHandler, CommandHandler, ContextTypes

from app import jitter, profiles

logger = logging.getLogger(__name__)

ENTRADA = 0
CB = "af"   # prefijo de los callback_data


# --------------------------------------------------------------------- formato
DIAS = ("lunes", "martes", "miércoles", "jueves", "viernes", "sábado", "domingo")
DIAS_CORTO = ("lun", "mar", "mié", "jue", "vie", "sáb", "dom")


def fecha_larga(d: date) -> str:
    return f"{DIAS[d.weekday()]} {d:%d/%m/%Y}"


def fecha_corta(d: date) -> str:
    return f"{DIAS_CORTO[d.weekday()]} {d:%d/%m}"


def hm(minutes: int) -> str:
    """Minutos -> '+1h 23m' / '-4m' / '0m'."""
    if not minutes:
        return "0m"
    sign = "-" if minutes < 0 else "+"
    m = abs(int(minutes))
    return f"{sign}{m // 60}h {m % 60:02d}m" if m >= 60 else f"{sign}{m}m"


def parse_day(txt: str, today: date) -> date | None:
    t = (txt or "").strip().lower()
    if t in ("", "hoy"):
        return today
    if t in ("mañana", "manana"):
        return today + timedelta(days=1)
    if t == "ayer":
        return today - timedelta(days=1)
    for fmt in ("%d/%m/%Y", "%d/%m/%y", "%d/%m", "%Y-%m-%d"):
        try:
            d = datetime.strptime(t, fmt).date()
            return d.replace(year=today.year) if fmt == "%d/%m" else d
        except ValueError:
            continue
    return None


def parse_range(args: list[str], today: date) -> list[date]:
    """'hoy', '05/10', '05/10-09/10' -> lista de fechas."""
    txt = " ".join(args).strip()
    if "-" in txt and not txt.startswith("-"):
        a, _, b = txt.partition("-")
        da, db = parse_day(a, today), parse_day(b, today)
        if da and db and da <= db:
            return [da + timedelta(days=i) for i in range((db - da).days + 1)]
        return []
    d = parse_day(txt, today)
    return [d] if d else []


# ------------------------------------------------------------------------ teclado
def check_result_text(lab: str, res: dict, manual: bool = False) -> str:
    """Resultado de un fichaje, contando si Timenet lo ha recortado."""
    if res.get("repeated"):
        return f"🕐 {lab}: Timenet dice que ya estaba fichado."
    rec, real = res.get("recorded"), res.get("real")
    head = f"{'✅ (manual)' if manual else '✅'} <b>{lab}</b> registrada"
    if rec and real and rec != real:
        return f"{head}\nFichado {real} → <b>cuenta como {rec}</b>"
    if rec:
        return f"{head} a las <b>{rec}</b>"
    return f"{head} (sin confirmación de hora)"


def pending_keyboard(day: date, idx: int) -> InlineKeyboardMarkup:
    d = day.isoformat()
    return InlineKeyboardMarkup([[
        InlineKeyboardButton("🛑 Cancelar hoy", callback_data=f"{CB}:cancel:{d}:{idx}"),
        InlineKeyboardButton("⏭ +15 min", callback_data=f"{CB}:delay:{d}:{idx}"),
        InlineKeyboardButton("✅ Fichar ya", callback_data=f"{CB}:now:{d}:{idx}"),
    ]])


# Lo que Telegram mostrara en el menu de comandos. Orden = orden en el menu.
MENU: list[tuple[str, str]] = [
    ("hoy",       "Plan y estado de hoy"),
    ("saldo",     "Saldo del mes y acumulado"),
    ("plan",      "Ver el plan y re-tirar los dados"),
    ("perfil",    "Ver y cambiar el perfil de jitter"),
    ("proximos",  "Previsión de los próximos días  [nº de días]"),
    ("fichar",    "Fichar ENTRADA ahora"),
    ("desfichar", "Fichar SALIDA ahora"),
    ("off",       "No fichar un dia  [hoy|dd/mm|dd/mm-dd/mm]"),
    ("on",        "Volver a fichar ese dia"),
    ("pausa",     "Parar el servicio"),
    ("reanudar",  "Retomar el servicio"),
    ("log",       "Ultimos eventos"),
    ("ayuda",     "Ayuda"),
]


class BotUI:
    def __init__(self, service):
        self.svc = service
        self.chat_id = int((service.cfg.get("telegram") or {}).get("chat_id"))

    # -------------------------------------------------------------- utilidades
    def _mine(self, update: Update) -> bool:
        chat = update.effective_chat
        if chat is None or chat.id != self.chat_id:
            logger.warning("mensaje ignorado de chat no autorizado: %s",
                           chat.id if chat else "?")
            return False
        return True

    def register(self, app: Application) -> None:
        cmds = {
            "start": self.cmd_hoy, "help": self.cmd_help, "ayuda": self.cmd_help,
            "hoy": self.cmd_hoy, "saldo": self.cmd_saldo, "plan": self.cmd_plan,
            "proximos": self.cmd_proximos, "perfil": self.cmd_perfil,
            "off": self.cmd_off, "on": self.cmd_on,
            "fichar": self.cmd_fichar, "desfichar": self.cmd_desfichar,
            "pausa": self.cmd_pausa, "reanudar": self.cmd_reanudar,
            "log": self.cmd_log,
        }
        for name, fn in cmds.items():
            app.add_handler(CommandHandler(name, self._guard(fn)))
        app.add_handler(CallbackQueryHandler(self.on_button, pattern=rf"^{CB}:"))

    def _guard(self, fn):
        async def wrapper(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
            if not self._mine(update):
                return
            try:
                await fn(update, ctx)
            except Exception as e:
                logger.exception("fallo en %s", fn.__name__)
                await update.effective_message.reply_text(f"🟥 Error en el comando: {e}")
        return wrapper

    async def send(self, text: str, keyboard=None):
        return await self.svc.app.bot.send_message(
            chat_id=self.chat_id, text=text, reply_markup=keyboard,
            parse_mode=ParseMode.HTML, disable_notification=False)

    # ---------------------------------------------------------------- comandos
    async def cmd_help(self, update: Update, ctx) -> None:
        cuerpo = "\n".join(f"/{c} — {d}" for c, d in MENU)
        await update.effective_message.reply_text(
            f"<b>Autoficher</b>\n\n{cuerpo}", parse_mode=ParseMode.HTML)

    async def publish_menu(self) -> None:
        """Registra los comandos en Telegram para que salgan en el menu del chat."""
        cmds = [BotCommand(c, d) for c, d in MENU]
        await self.svc.app.bot.set_my_commands(
            cmds, scope=BotCommandScopeChat(chat_id=self.chat_id))
        logger.info("menu de comandos publicado en Telegram (%d comandos)", len(cmds))

    async def cmd_hoy(self, update: Update, ctx) -> None:
        await update.effective_message.reply_text(await self._status_text(),
                                                  parse_mode=ParseMode.HTML)

    async def _status_text(self) -> str:
        today = self.svc.today()
        lines = [f"<b>{fecha_larga(today)}</b>"]

        cal = await asyncio.to_thread(self.svc.executor.calendar)
        if not cal.is_workday(today):
            lines.append(f"🌴 No laborable: <i>{cal.why_not_workday(today)}</i>")
        else:
            dt = cal.day_type(today)
            lines.append(f"🗓 {dt.name} · previsto {dt.minutes} min")

        ov = self.svc.store.get_override(today)
        if ov:
            lines.append(f"🚫 Desactivado a mano: <i>{ov['reason'] or 'sin motivo'}</i>")
        if self.svc.is_paused():
            lines.append("⏸ <b>Servicio en pausa</b>")

        plan = self.svc.store.get_plan(today)
        if plan:
            lines.append("\n<b>Plan de hoy</b>")
            icon = {"pending": "⏳", "done": "✅", "cancelled": "🛑",
                    "skipped": "⤵️", "failed": "🟥"}
            for r in plan:
                t = datetime.fromisoformat(r["planned_at"])
                lab = "ENTRADA" if r["typ"] == ENTRADA else "SALIDA "
                extra = ""
                if r["state"] == "done" and r["fired_at"]:
                    extra = f" → fichado {datetime.fromisoformat(r['fired_at']):%H:%M:%S}"
                lines.append(f"{icon.get(r['state'], '·')} <code>{t:%H:%M:%S}</code> {lab}{extra}")

        try:
            s = await asyncio.to_thread(self.svc.executor.today_summary)
            if s["checks"]:
                lines.append("\n<b>Según Timenet</b>")
                for c in s["checks"]:
                    lab = "entrada" if c["typ"] == ENTRADA else "salida "
                    mark = "" if c["recorded"] == c["real"] else f"  (fichado {c['real']}, recortado)"
                    lines.append(f"· {lab} <code>{c['recorded']}</code>{mark}")
                lines.append(f"trabajado {s['W']}/{s['P']} min · saldo del día <b>{hm(s['X'])}</b>")
        except Exception as e:
            lines.append(f"\n⚠️ No se pudo leer Timenet: {e}")
        return "\n".join(lines)

    async def cmd_saldo(self, update: Update, ctx) -> None:
        b = await asyncio.to_thread(self.svc.executor.balance)
        await update.effective_message.reply_text(
            f"<b>Saldo</b>\n"
            f"Mes en curso: previsto {b['P']} min · trabajado {b['W']} min\n"
            f"Saldo del mes: <b>{hm(b['X'])}</b>\n"
            f"Arrastrado: {hm(b['XAnt'])}\n"
            f"━━━━━━━━━━━━━\n"
            f"<b>Acumulado: {hm(b['total'])}</b>",
            parse_mode=ParseMode.HTML)

    async def cmd_plan(self, update: Update, ctx) -> None:
        kb = InlineKeyboardMarkup([[InlineKeyboardButton(
            "🎲 Re-tirar el plan de hoy", callback_data=f"{CB}:replan:{self.svc.today()}:0")]])
        await update.effective_message.reply_text(await self._status_text(),
                                                  parse_mode=ParseMode.HTML, reply_markup=kb)

    async def cmd_proximos(self, update: Update, ctx) -> None:
        try:
            ndias = max(1, min(45, int(ctx.args[0]))) if ctx.args else 14
        except ValueError:
            ndias = 14

        cal = await asyncio.to_thread(self.svc.executor.calendar)
        hoy = self.svc.today()
        icon = {"pending": "⏳", "done": "✅", "cancelled": "🛑",
                "skipped": "⤵️", "failed": "🟥"}
        lines = [f"<b>Previsión · próximos {ndias} días</b>"]
        laborables = 0

        for i in range(ndias):
            d = hoy + timedelta(days=i)
            cab = f"<b>{fecha_corta(d)}</b>"

            ov = self.svc.store.get_override(d)
            if ov and ov["action"] == "off":
                lines.append(f"{cab} 🚫 <i>{ov['reason'] or 'desactivado a mano'}</i>")
                continue
            if not cal.is_workday(d):
                lines.append(f"{cab} 🌴 <i>{cal.why_not_workday(d)}</i>")
                continue

            laborables += 1
            plan = self.svc.store.get_plan(d)
            if plan:
                trozos = [f"{icon.get(r['state'], '·')}"
                          f"{datetime.fromisoformat(r['planned_at']):%H:%M:%S}"
                          for r in plan]
                lines.append(f"{cab} <code>{' '.join(trozos)}</code>")
            else:
                # mas alla del horizonte que se planifica por adelantado
                tramos = "  ".join(str(w) for w in cal.windows(d))
                lines.append(f"{cab} <code>{tramos}</code> <i>(sin planificar aún)</i>")

        b = await asyncio.to_thread(self.svc.executor.balance)
        lines.append(f"\n{laborables} días laborables · saldo acumulado <b>{hm(b['total'])}</b>")
        await update.effective_message.reply_text("\n".join(lines),
                                                  parse_mode=ParseMode.HTML)

    def _perfil_texto(self) -> str:
        actual = self.svc.store.get("perfil", profiles.DEFECTO)
        lines = ["<b>Perfil de jitter</b>",
                 "Cuánta variedad tienen las horas de fichaje, y lo que cuesta "
                 "en minutos de estar ahí. Todos dan saldo 0.\n"]
        for n in profiles.nombres():
            st = profiles.stats(n)
            marca = "▶️ " if n == actual else "· "
            lines.append(
                f"{marca}<b>{profiles.titulo(n)}</b> — {st['coste']:.1f} min/día "
                f"(madrugón {st['madrugon']:.1f}) · {st['mins']} minutos, moda {st['moda']}%")
            lines.append(f"   <i>{profiles.resumen(n)}</i>")
        lines.append("\n<i>madrugón = de esos minutos, los que te levantas antes "
                     "por la entrada de la mañana. Tu histórico real: 4 minutos, moda 38%.</i>")
        real = self._histograma_real()
        if real:
            lines.append("\n" + real)
        return "\n".join(lines)

    def _histograma_real(self) -> str:
        """Lo que hay sorteado ahora mismo, para poder ver el efecto del cambio."""
        from collections import Counter
        hoy = self.svc.today()
        c: Counter = Counter()
        for i in range(60):
            for r in self.svc.store.get_plan(hoy + timedelta(days=i)):
                t = datetime.fromisoformat(r["target"])
                if r["typ"] == ENTRADA and (t.hour, t.minute) == (9, 0):
                    c[datetime.fromisoformat(r["planned_at"]).strftime("%H:%M")] += 1
        if not c:
            return ""
        tot = sum(c.values())
        filas = "\n".join(
            f"  <code>{h}</code> {'█' * n} {n}" for h, n in sorted(c.items()))
        return (f"<b>Tus próximos {tot} días ya sorteados</b> (entrada de la mañana)\n"
                f"{filas}\n  <i>{len(c)} horas distintas · la más repetida "
                f"{max(c.values())} de {tot} ({round(100 * max(c.values()) / tot)}%)</i>")

    def _perfil_teclado(self) -> InlineKeyboardMarkup:
        actual = self.svc.store.get("perfil", profiles.DEFECTO)
        botones = [InlineKeyboardButton(
            ("✅ " if n == actual else "") + profiles.titulo(n),
            callback_data=f"{CB}:perfil:{n}") for n in profiles.nombres()]
        filas = [botones[i:i + 2] for i in range(0, len(botones), 2)]
        return InlineKeyboardMarkup(filas)

    async def cmd_perfil(self, update: Update, ctx) -> None:
        if ctx.args:
            n = ctx.args[0].strip().lower()
            if not profiles.existe(n):
                await update.effective_message.reply_text(
                    "No conozco ese perfil. Son: " + ", ".join(profiles.nombres()))
                return
            await self.svc.cambiar_perfil(n)
            await update.effective_message.reply_text(
                f"✅ Perfil <b>{profiles.titulo(n)}</b>. Replanificados los días futuros.",
                parse_mode=ParseMode.HTML)
            return
        await update.effective_message.reply_text(
            self._perfil_texto(), parse_mode=ParseMode.HTML,
            reply_markup=self._perfil_teclado())

    async def _cambiar_perfil(self, q, nombre: str) -> None:
        if not profiles.existe(nombre):
            await q.answer("Perfil desconocido")
            return
        await q.answer(f"Cambiando a {profiles.titulo(nombre)}…")
        await self.svc.cambiar_perfil(nombre)
        await q.edit_message_text(
            self._perfil_texto() + "\n\n<b>Replanificados los días futuros.</b>",
            parse_mode=ParseMode.HTML, reply_markup=self._perfil_teclado())

    async def cmd_off(self, update: Update, ctx) -> None:
        days = parse_range(ctx.args, self.svc.today())
        if not days:
            await update.effective_message.reply_text(
                "Uso: /off [hoy | mañana | dd/mm | dd/mm-dd/mm]")
            return
        for d in days:
            self.svc.store.set_override(d, "off", "desde Telegram")
        self.svc.store.log("override", f"off {days[0]}..{days[-1]}")
        if self.svc.today() in days:
            await self.svc.cancel_pending_today("desactivado a mano")
        await update.effective_message.reply_text(
            f"🚫 No se fichará {'el ' + days[0].strftime('%d/%m') if len(days) == 1 else f'del {days[0]:%d/%m} al {days[-1]:%d/%m} ({len(days)} días)'}")

    async def cmd_on(self, update: Update, ctx) -> None:
        days = parse_range(ctx.args, self.svc.today())
        if not days:
            await update.effective_message.reply_text("Uso: /on [hoy | dd/mm | dd/mm-dd/mm]")
            return
        for d in days:
            self.svc.store.clear_override(d)
        if self.svc.today() in days:
            await self.svc.ensure_plan(force=True)
        await update.effective_message.reply_text(
            f"✅ Reactivado ({len(days)} día{'s' if len(days) > 1 else ''})")

    async def cmd_fichar(self, update: Update, ctx) -> None:
        await self._manual(update, ENTRADA)

    async def cmd_desfichar(self, update: Update, ctx) -> None:
        await self._manual(update, 1)

    async def _manual(self, update: Update, typ: int) -> None:
        lab = "ENTRADA" if typ == ENTRADA else "SALIDA"
        msg = await update.effective_message.reply_text(f"⏳ Fichando {lab} a mano…")
        try:
            res = await asyncio.to_thread(self.svc.executor.do_check, typ)
            self.svc.store.log("manual", f"{lab} -> {res.get('recorded')}")
            await msg.edit_text(check_result_text(lab, res, manual=True),
                                parse_mode=ParseMode.HTML)
        except Exception as e:
            logger.exception("fallo en fichaje manual")
            await msg.edit_text(f"🟥 No se pudo fichar {lab}: {e}")

    async def cmd_pausa(self, update: Update, ctx) -> None:
        self.svc.set_paused(True)
        await self.svc.cancel_pending_today("servicio en pausa")
        await update.effective_message.reply_text("⏸ Servicio en pausa. /reanudar para volver.")

    async def cmd_reanudar(self, update: Update, ctx) -> None:
        self.svc.set_paused(False)
        await self.svc.ensure_plan(force=True)
        await update.effective_message.reply_text("▶️ Servicio reanudado.\n\n" +
                                                  await self._status_text(),
                                                  parse_mode=ParseMode.HTML)

    async def cmd_log(self, update: Update, ctx) -> None:
        ev = self.svc.store.recent_events(15)
        if not ev:
            await update.effective_message.reply_text("Sin eventos todavía.")
            return
        txt = "\n".join(f"<code>{e['ts'][5:16]}</code> {e['kind']}: {e['msg'][:80]}"
                        for e in ev)
        await update.effective_message.reply_text(f"<b>Últimos eventos</b>\n{txt}",
                                                  parse_mode=ParseMode.HTML)

    # --------------------------------------------------------------- callbacks
    async def on_button(self, update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
        q = update.callback_query
        if not self._mine(update):
            await q.answer()
            return
        partes = q.data.split(":")
        action = partes[1] if len(partes) > 1 else ""

        if action == "perfil":
            await self._cambiar_perfil(q, partes[2])
            return

        try:
            day, idx = date.fromisoformat(partes[2]), int(partes[3])
        except (IndexError, ValueError):
            await q.answer("Botón no reconocido")
            return

        try:
            if action == "cancel":
                self.svc.store.set_state(day, idx, "cancelled", note="cancelado desde Telegram")
                self.svc.store.log("killswitch", f"cancelado {day} idx={idx}")
                await q.answer("Cancelado")
                await q.edit_message_text("🛑 <b>Fichaje cancelado</b> desde Telegram.",
                                          parse_mode=ParseMode.HTML)

            elif action == "delay":
                row = self.svc.store.get_check(day, idx)
                if not row or row["state"] != "pending":
                    await q.answer("Ya no está pendiente")
                    return
                nuevo = datetime.fromisoformat(row["planned_at"]) + timedelta(minutes=15)
                self.svc.store.reschedule(day, idx, nuevo)
                self.svc.wake()
                await q.answer("Retrasado 15 min")
                await q.edit_message_text(
                    f"⏭ Fichaje retrasado a las <b>{nuevo:%H:%M:%S}</b>.",
                    parse_mode=ParseMode.HTML)

            elif action == "now":
                await q.answer("Fichando…")
                await q.edit_message_text("⏳ Fichando ahora…")
                ok = await self.svc.fire(day, idx, reason="botón «fichar ya»")
                await q.edit_message_text(ok, parse_mode=ParseMode.HTML)

            elif action == "replan":
                await self.svc.ensure_plan(force=True)
                await q.answer("Plan regenerado")
                await q.edit_message_text(await self._status_text(),
                                          parse_mode=ParseMode.HTML)
            else:
                await q.answer("Acción desconocida")
        except Exception as e:
            logger.exception("fallo en callback %s", q.data)
            await q.answer("Error")
            await self.send(f"🟥 Error procesando el botón: {e}")