jigaido/apps/telegram-bot/commands.py

"""Telegram command handlers for JIGAIDO - Thin wrappers around core services."""

import time
from functools import wraps
from typing import Optional

import dateparser
from telegram import Update
from telegram.ext import ContextTypes

from adapters.storage.json_file import JsonFileRoomStorage, JsonFileTrackingStorage
from core.services import BountyService, TrackingService

ROOM_STORAGE = JsonFileRoomStorage()
TRACKING_STORAGE = JsonFileTrackingStorage()
BOUNTY_SERVICE = BountyService(ROOM_STORAGE)
TRACKING_SERVICE = TrackingService(TRACKING_STORAGE, ROOM_STORAGE)

TELEGRAM_BOT_USERNAME = "your_bot_username"


def extract_args(text: str) -> list[str]:
    if not text:
        return []
    tokens = text.strip().split()
    return tokens[1:] if len(tokens) > 1 else []


def parse_args(args: list[str]) -> tuple[Optional[str], Optional[str], Optional[int]]:
    text = None
    link = None
    due_date_ts = None

    remaining = []
    for arg in args:
        if not link and (arg.startswith("http://") or arg.startswith("https://")):
            link = arg
        elif due_date_ts is None:
            parsed = dateparser.parse(arg)
            if parsed:
                due_date_ts = int(parsed.timestamp())
            else:
                remaining.append(arg)
        else:
            remaining.append(arg)

    text = " ".join(remaining) if remaining else None
    return text, link, due_date_ts


def format_bounty(b, show_id: bool = True, slice_length: int = 0) -> str:
    parts = []
    if show_id:
        parts.append(f"[#{b.id}]")
    if b.text:
        text = b.text
        if slice_length > 0 and len(text) > slice_length:
            text = text[:slice_length] + "..."
        parts.append(text)
    if b.link:
        parts.append(f"🔗 {b.link}")
    if b.due_date_ts:
        due_str = time.strftime("%d %b %Y", time.localtime(b.due_date_ts))
        days_left = (b.due_date_ts - int(time.time())) // 86400
        if days_left < 0:
            parts.append(f"⏰ {due_str} (OVERDUE)")
        elif days_left == 0:
            parts.append(f"⏰ Today (OVERDUE)")
        else:
            parts.append(f"⏰ {due_str} ({days_left}d)")
    if b.created_by_user_id:
        parts.append(f"by {b.created_by_user_id}")
    return " | ".join(parts)


def is_group(update: Update) -> bool:
    return update.effective_chat.type != "private"


def get_group_id(update: Update) -> int:
    return update.effective_chat.id


def get_user_id(update: Update) -> int:
    return update.effective_user.id


def get_room_id(update: Update) -> int:
    """Get room_id for the current context.

    For groups: negative group_id
    For DMs: positive user_id
    """
    if is_group(update):
        return get_group_id(update)
    return get_user_id(update)


async def cmd_bounty(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
    room_id = get_room_id(update)
    args = extract_args(update.message.text)

    show_all = "all" in args
    args = [a for a in args if a != "all"]

    try:
        limit = int(args[0]) if args else 5
    except (ValueError, IndexError):
        limit = 5

    now = int(time.time())
    cutoff_24h = now - 86400

    all_bounties = BOUNTY_SERVICE.list_bounties(room_id)

    def is_expired(b) -> bool:
        return b.due_date_ts is not None and b.due_date_ts < cutoff_24h

    def sort_key(b):
        if b.due_date_ts is not None:
            return (0, b.due_date_ts)
        return (1, b.created_at)

    filtered_bounties = [b for b in all_bounties if not is_expired(b) or show_all]
    filtered_bounties.sort(key=sort_key)

    total_count = len(filtered_bounties)
    displayed_bounties = filtered_bounties[:limit]

    if not displayed_bounties:
        if show_all:
            await update.message.reply_text("No bounties yet.")
        else:
            await update.message.reply_text(
                "No active bounties. Use /bounty all to show expired."
            )
        return

    lines = []
    if limit < total_count:
        lines.append(f"Showing {limit} of {total_count} bounties:")
        slice_length = 40
    elif show_all and total_count > limit:
        lines.append(f"Showing {limit} of {total_count} bounties (including expired):")
        slice_length = 40
    else:
        lines.append(f"Showing {total_count} bounties:")
        slice_length = 0

    for b in displayed_bounties:
        lines.append(format_bounty(b, show_id=True, slice_length=slice_length))

    await update.message.reply_text("\n".join(lines), disable_web_page_preview=True)


async def cmd_my(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
    user_id = get_user_id(update)

    if is_group(update):
        group_id = get_group_id(update)
        bounties = TRACKING_SERVICE.get_tracked_bounties(group_id, user_id)
    else:
        room_id = get_room_id(update)
        bounties = BOUNTY_SERVICE.list_bounties(room_id)

    if not bounties:
        msg = (
            "You are not tracking any bounties."
            if is_group(update)
            else "No personal bounties."
        )
        await update.message.reply_text(msg)
        return

    lines = [format_bounty(b, show_id=True) for b in bounties]
    await update.message.reply_text("\n".join(lines), disable_web_page_preview=True)


async def cmd_add(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
    args = extract_args(update.message.text)
    if not args:
        await update.message.reply_text(
            "Usage: /add <text> [link] [due_date]\n"
            "Example: /add Fix the bug https://github.com/foo/bar tomorrow"
        )
        return

    text, link, due_date_ts = parse_args(args)
    if not text and not link:
        await update.message.reply_text("A bounty needs at least text or a link.")
        return

    user_id = get_user_id(update)
    room_id = get_room_id(update)

    bounty = BOUNTY_SERVICE.add_bounty(
        room_id=room_id,
        user_id=user_id,
        text=text,
        link=link,
        due_date_ts=due_date_ts,
    )

    due_str = ""
    if due_date_ts:
        due_str = f" | Due: {time.strftime('%Y-%m-%d', time.localtime(due_date_ts))}"

    await update.message.reply_text(
        f"✅ Bounty added (#{bounty.id}){due_str}",
        disable_web_page_preview=True,
    )


async def cmd_update(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
    args = extract_args(update.message.text)
    if len(args) < 1:
        await update.message.reply_text(
            "Usage: /update <bounty_id> [text] [link] [due_date]"
        )
        return

    try:
        bounty_id = int(args[0])
    except ValueError:
        await update.message.reply_text("Invalid bounty ID.")
        return

    text, link, due_date_ts = parse_args(args[1:])
    if not text and not link and due_date_ts is None:
        await update.message.reply_text("Nothing to update.")
        return

    user_id = get_user_id(update)
    room_id = get_room_id(update)

    try:
        success = BOUNTY_SERVICE.update_bounty(
            room_id=room_id,
            bounty_id=bounty_id,
            user_id=user_id,
            text=text,
            link=link,
            due_date_ts=due_date_ts,
        )
    except PermissionError as e:
        await update.message.reply_text(f"⛔ {e}")
        return

    if success:
        await update.message.reply_text(f"✅ Bounty #{bounty_id} updated.")
    else:
        await update.message.reply_text("Bounty not found.")


cmd_edit = cmd_update


async def cmd_delete(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
    args = extract_args(update.message.text)
    if not args:
        await update.message.reply_text("Usage: /delete <bounty_id>")
        return

    try:
        bounty_id = int(args[0])
    except ValueError:
        await update.message.reply_text("Invalid bounty ID.")
        return

    user_id = get_user_id(update)
    room_id = get_room_id(update)

    try:
        success = BOUNTY_SERVICE.delete_bounty(
            room_id=room_id,
            bounty_id=bounty_id,
            user_id=user_id,
        )
    except PermissionError as e:
        await update.message.reply_text(f"⛔ {e}")
        return

    if success:
        await update.message.reply_text(f"✅ Bounty #{bounty_id} deleted.")
    else:
        await update.message.reply_text("Bounty not found.")


async def cmd_track(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
    if not is_group(update):
        await update.message.reply_text("⛔ /track is only available in groups.")
        return

    args = extract_args(update.message.text)
    if not args:
        await update.message.reply_text("Usage: /track <bounty_id>")
        return

    try:
        bounty_id = int(args[0])
    except ValueError:
        await update.message.reply_text("Invalid bounty ID.")
        return

    user_id = get_user_id(update)
    room_id = get_room_id(update)

    try:
        if TRACKING_SERVICE.track_bounty(room_id, user_id, bounty_id):
            await update.message.reply_text(f"✅ Now tracking bounty #{bounty_id}.")
        else:
            await update.message.reply_text(f"Already tracking bounty #{bounty_id}.")
    except ValueError as e:
        await update.message.reply_text(str(e))


async def cmd_untrack(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
    if not is_group(update):
        await update.message.reply_text("⛔ /untrack is only available in groups.")
        return

    args = extract_args(update.message.text)
    if not args:
        await update.message.reply_text("Usage: /untrack <bounty_id>")
        return

    try:
        bounty_id = int(args[0])
    except ValueError:
        await update.message.reply_text("Invalid bounty ID.")
        return

    user_id = get_user_id(update)
    room_id = get_room_id(update)

    if TRACKING_SERVICE.untrack_bounty(room_id, user_id, bounty_id):
        await update.message.reply_text(f"✅ Untracked bounty #{bounty_id}.")
    else:
        await update.message.reply_text("Not tracking bounty #{bounty_id}.")


async def cmd_start(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
    if is_group(update):
        await update.message.reply_text(
            "👻 JIGAIDO is watching.\n\n"
            "This group's bounty list is now active.\n"
            "/bounty — list bounties\n"
            "/add — create a bounty\n"
            "/track — track a bounty\n"
            "/my — your tracked bounties"
        )
    else:
        await update.message.reply_text(
            "👻 JIGAIDO activated.\n\n"
            "Personal bounty list ready.\n"
            "/bounty — list your bounties\n"
            "/add — create a bounty\n"
            "/my — your tracked bounties"
        )


async def cmd_help(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(
        "👻 JIGAIDO Commands:\n\n"
        "/bounty — list all bounties\n"
        "/my — bounties you're tracking\n"
        "/add <text> [link] [due] — add bounty\n"
        "/update <id> [text> [link] [due] — update bounty\n"
        "/delete <id> — delete bounty\n"
        "/track <id> — track a bounty (groups only)\n"
        "/untrack <id> — stop tracking (groups only)\n"
        "/start — re-initialize\n"
        "/help — this message",
        disable_web_page_preview=True,
    )