"""ThirdEye Telegram Bot — main entry point."""

import asyncio
import logging
import os
import tempfile
from backend.config import ENABLE_DOCUMENT_INGESTION
from backend.agents.document_ingestor import ingest_document
from backend.db.chroma import store_signals, set_group_name
from collections import defaultdict
from telegram import Update
from telegram.ext import (
    Application,
    MessageHandler,
    CommandHandler,
    filters,
    ContextTypes,
)
from backend.config import TELEGRAM_BOT_TOKEN, BATCH_SIZE
from backend.pipeline import (
    process_message_batch,
    query_knowledge,
    get_lens,
    set_lens,
    detect_and_set_lens,
)
from backend.agents.web_search import search_web, format_search_results_for_llm
from backend.agents.link_fetcher import extract_urls, process_links_from_message
from backend.config import ENABLE_LINK_FETCH

from backend.config import ENABLE_WEB_SEARCH


logging.basicConfig(
    level=logging.INFO, format="%(asctime)s [%(name)s] %(levelname)s: %(message)s"
)
logger = logging.getLogger("thirdeye.bot")

# Message buffers per group
_buffers = defaultdict(list)
_group_names = {}
_flush_timers = {}  # Track pending flush timers per group


async def _flush_buffer(group_id: str):
    """Flush the message buffer for a specific group (timer callback)."""
    if group_id not in _buffers or not _buffers[group_id]:
        return

    batch = _buffers[group_id]
    _buffers[group_id] = []

    # Clear the timer reference
    if group_id in _flush_timers:
        del _flush_timers[group_id]

    try:
        signals = await process_message_batch(group_id, batch)
        if signals:
            logger.info(
                f"Timer flush: {len(signals)} signals from {_group_names.get(group_id, group_id)} ({len(batch)} messages)"
            )
    except Exception as e:
        logger.error(f"Timer flush failed for {group_id}: {e}")


def _schedule_flush(group_id: str):
    """Schedule a flush for this group after BATCH_TIMEOUT_SECONDS."""
    from backend.config import BATCH_TIMEOUT_SECONDS

    # Cancel existing timer if any
    if group_id in _flush_timers:
        _flush_timers[group_id].cancel()

    # Schedule new flush
    loop = asyncio.get_event_loop()
    timer = loop.call_later(
        BATCH_TIMEOUT_SECONDS, lambda: asyncio.create_task(_flush_buffer(group_id))
    )
    _flush_timers[group_id] = timer


async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Process every text message in groups."""
    if not update.message or not update.message.text:
        return
    if not update.message.chat.type in ("group", "supergroup"):
        return

    group_id = str(update.message.chat_id)
    chat_title = update.message.chat.title or group_id
    _group_names[group_id] = chat_title
    set_group_name(group_id, chat_title)
    text = update.message.text
    sender = (
        update.message.from_user.first_name
        or update.message.from_user.username
        or "Unknown"
    )

    msg = {
        "sender": sender,
        "text": text,
        "timestamp": update.message.date.isoformat(),
        "message_id": update.message.message_id,
    }

    _buffers[group_id].append(msg)

    # Schedule or reschedule the flush timer
    # If buffer was empty before, this starts the timer
    # If buffer had messages, this resets the timer
    if len(_buffers[group_id]) == 1:
        # First message in buffer - start the timer
        _schedule_flush(group_id)

    # Process immediately when buffer reaches batch size
    if len(_buffers[group_id]) >= BATCH_SIZE:
        # Cancel the timer since we're processing now
        if group_id in _flush_timers:
            _flush_timers[group_id].cancel()
            del _flush_timers[group_id]

        batch = _buffers[group_id]
        _buffers[group_id] = []

        try:
            signals = await process_message_batch(group_id, batch)
            if signals:
                logger.info(
                    f"Processed batch: {len(signals)} signals from {_group_names.get(group_id, group_id)}"
                )
        except Exception as e:
            logger.error(f"Pipeline error: {e}")

    # Background: process links if message contains URLs
    if ENABLE_LINK_FETCH and extract_urls(text):
        asyncio.create_task(_process_links_background(text, group_id, sender))


async def _process_links_background(text: str, group_id: str, sender: str):
    """Process links from a message in the background (non-blocking)."""
    try:
        link_signals = await process_links_from_message(
            text, group_id, shared_by=sender
        )
        if link_signals:
            store_signals(group_id, link_signals)
            logger.info(f"Stored {len(link_signals)} link signals for {group_id}")
    except Exception as e:
        logger.error(f"Background link processing failed: {e}")


async def _process_document_background(
    doc, filename, group_id, shared_by, chat_id, context
):
    """Background task to process document without blocking Telegram."""
    file_path = None
    tmp_dir = None

    try:
        # Download file to temp directory
        tg_file = await doc.get_file()
        tmp_dir = tempfile.mkdtemp()
        file_path = os.path.join(tmp_dir, filename)
        await tg_file.download_to_drive(file_path)

        logger.info(
            f"Downloaded {filename} from {shared_by} in {_group_names.get(group_id, group_id)}"
        )

        # Ingest into knowledge base (this is the slow part)
        signals = ingest_document(
            file_path, group_id, shared_by=shared_by, filename=filename
        )

        if signals:
            store_signals(group_id, signals)
            # Send success message
            await context.bot.send_message(
                chat_id=chat_id,
                text=f"✅ *{filename}* processed — {len(signals)} knowledge chunks stored.\nYou can now `/ask` questions about this document.",
                parse_mode="Markdown",
            )
            logger.info(f"Successfully ingested {filename}: {len(signals)} signals")
        else:
            logger.info(f"No extractable text in {filename}")
            await context.bot.send_message(
                chat_id=chat_id,
                text=f"⚠️ *{filename}* - No text could be extracted from this file.",
                parse_mode="Markdown",
            )

    except Exception as e:
        logger.error(f"Document ingestion failed for {filename}: {e}")
        try:
            await context.bot.send_message(
                chat_id=chat_id,
                text=f"❌ Failed to process *{filename}*: {str(e)[:100]}",
                parse_mode="Markdown",
            )
        except Exception:
            pass
    finally:
        # Cleanup temp file
        try:
            if file_path and os.path.exists(file_path):
                os.remove(file_path)
            if tmp_dir and os.path.exists(tmp_dir):
                os.rmdir(tmp_dir)
        except Exception as e:
            logger.warning(f"Cleanup failed for {filename}: {e}")


async def handle_document(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Process documents/files shared in groups."""
    if not ENABLE_DOCUMENT_INGESTION:
        return
    if not update.message or not update.message.document:
        return
    if not update.message.chat.type in ("group", "supergroup"):
        return

    doc = update.message.document
    filename = doc.file_name or "unknown_file"
    ext = os.path.splitext(filename)[1].lower()

    # Only process supported file types
    supported = {".pdf", ".docx", ".txt", ".md", ".csv", ".json", ".log"}
    if ext not in supported:
        return

    # Size guard: skip files over 10MB
    if doc.file_size and doc.file_size > 10 * 1024 * 1024:
        await update.message.reply_text(
            f"⚠️ File too large: *{filename}* ({doc.file_size / 1024 / 1024:.1f} MB). Max size: 10 MB.",
            parse_mode="Markdown",
        )
        return

    group_id = str(update.message.chat_id)
    shared_by = (
        update.message.from_user.first_name
        or update.message.from_user.username
        or "Unknown"
    )
    chat_title = update.message.chat.title or group_id
    _group_names[group_id] = chat_title
    set_group_name(group_id, chat_title)

    # Respond immediately so Telegram doesn't timeout
    await update.message.reply_text(
        f"📄 Processing *{filename}*...\n_This may take a minute for large files._",
        parse_mode="Markdown",
    )

    # Process in background
    asyncio.create_task(
        _process_document_background(
            doc, filename, group_id, shared_by, update.message.chat_id, context
        )
    )


async def cmd_ask(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Handle /ask [question] — also supports /ask raise jira [topic] to raise tickets inline."""
    if not context.args:
        await update.message.reply_text(
            "Usage: /ask [your question]\n"
            "Example: /ask What database did we choose?\n"
            "Tip: /ask raise jira on [topic] — raise Jira tickets matching a topic"
        )
        return

    question = " ".join(context.args)
    group_id = str(update.message.chat_id)

    # ── Jira assign intent detection (checked before raise) ──────────────────
    _ASSIGN_TRIGGERS = (
        "assign jira",
        "assign ticket",
        "assign a jira",
        "assign a ticket",
        "assign the jira",
        "assign the ticket",
    )
    if any(trigger in question.lower() for trigger in _ASSIGN_TRIGGERS):
        await _handle_ask_jira_assign(update, context, question, group_id)
        return

    # ── Jira raise intent detection ───────────────────────────────────────────
    _RAISE_TRIGGERS = (
        "raise jira",
        "jira raise",
        "create jira",
        "file jira",
        "open jira",
        "raise ticket",
        "create ticket",
        "raise a jira",
        "raise jira ticket",
        "raise jira token",  # common autocorrect/typo variant
    )
    if any(trigger in question.lower() for trigger in _RAISE_TRIGGERS):
        await _handle_ask_jira_raise(update, context, question, group_id)
        return

    await update.message.reply_text("🔍 Searching the knowledge base...")

    # Flush any buffered messages for this group so /ask always sees the latest content.
    # Without this, a message sent moments before /ask might still be sitting in the buffer.
    if _buffers.get(group_id):
        batch = _buffers[group_id]
        _buffers[group_id] = []
        if group_id in _flush_timers:
            _flush_timers[group_id].cancel()
            del _flush_timers[group_id]
        try:
            await process_message_batch(group_id, batch)
        except Exception as e:
            logger.warning(f"Pre-ask flush failed for {group_id}: {e}")

    try:
        answer = await query_knowledge(group_id, question)
        await update.message.reply_text(f"💡 {answer}")
    except Exception as e:
        await update.message.reply_text(f"Sorry, something went wrong: {str(e)[:100]}")


async def _handle_ask_jira_assign(update, context, question: str, group_id: str):
    """
    Handle: /ask assign jira ticket for [topic] to [Name]
    Raises a new Jira ticket for the best matching signal and assigns it to the
    named person. If the signal was already raised, assigns the existing ticket instead.
    """
    import re
    from backend.integrations.jira_client import is_configured, assign_issue
    from backend.agents.jira_agent import (
        raise_ticket_for_signal,
        RAISEABLE_TYPES,
        resolve_assignee_account_id,
    )
    from backend.db.chroma import query_signals, get_all_signals, get_raised_signal_ids

    if not is_configured():
        await update.message.reply_text(
            "⚙️ Jira is not configured. Add `JIRA_BASE_URL`, `JIRA_EMAIL`, and `JIRA_API_TOKEN` "
            "to your .env and restart.",
            parse_mode="Markdown",
        )
        return

    # Parse assignee from "… to [Name]" at the end of the query
    assignee_name = None
    topic = question
    to_match = re.search(r'\bto\s+([A-Za-z][A-Za-z\s]{1,40}?)$', question, re.IGNORECASE)
    if to_match:
        assignee_name = to_match.group(1).strip()
        topic = question[: to_match.start()].strip()

    # Strip assign intent keywords from topic
    _STRIP_PATTERNS = [
        r"assign\s+(a\s+|the\s+)?(jira\s+)?(ticket|tickets)?\s*(for|on|about|regarding)?\s*(the\s*)?",
        r"assign\s+jira\s*(ticket|tickets)?\s*(for|on|about|regarding)?\s*(the\s*)?",
    ]
    for pattern in _STRIP_PATTERNS:
        topic = re.sub(pattern, "", topic, flags=re.IGNORECASE).strip()
    topic = topic.strip(" .,!?") or "priority task"

    if not assignee_name:
        await update.message.reply_text(
            "Usage: `/ask assign jira ticket for [topic] to [Name]`\n"
            "Example: `/ask assign jira ticket for design implementation to Anirban Basak`",
            parse_mode="Markdown",
        )
        return

    await update.message.reply_text(
        f"🔍 Finding signals for _{topic}_...", parse_mode="Markdown"
    )

    # Resolve Jira account ID before doing anything else
    account_id = await resolve_assignee_account_id(assignee_name)
    if not account_id:
        await update.message.reply_text(
            f"❌ Could not find *{assignee_name}* in Jira.\n"
            "Make sure the name matches their Jira display name exactly.",
            parse_mode="Markdown",
        )
        return

    # Flush pending buffer so we see the latest messages
    if _buffers.get(group_id):
        batch = _buffers[group_id]
        _buffers[group_id] = []
        if group_id in _flush_timers:
            _flush_timers[group_id].cancel()
            del _flush_timers[group_id]
        try:
            await process_message_batch(group_id, batch)
        except Exception as e:
            logger.warning(f"Pre-assign flush failed for {group_id}: {e}")

    already_raised = get_raised_signal_ids(group_id)

    # Semantic search for the best matching signal
    semantic_hits = query_signals(group_id, topic, n_results=10)
    candidates = [
        r for r in semantic_hits
        if r.get("metadata", {}).get("type") in RAISEABLE_TYPES
    ]
    if not candidates:
        all_sigs = get_all_signals(group_id)
        candidates = [
            {"id": s["id"], "document": s["document"], "metadata": s["metadata"]}
            for s in all_sigs
            if s.get("metadata", {}).get("type") in RAISEABLE_TYPES
        ][:3]

    if not candidates:
        await update.message.reply_text(
            f"📭 No raiseable signals found for *{topic}* in this group.",
            parse_mode="Markdown",
        )
        return

    # Take the single best candidate
    best = candidates[0]
    meta = best.get("metadata", {})
    sig_id = best.get("id", "")

    await update.message.reply_text(
        f"🚀 Raising ticket and assigning to *{assignee_name}*...", parse_mode="Markdown"
    )

    # If already raised, just assign the existing ticket
    if sig_id in already_raised:
        # The jira_key is stored in the raised signal entities
        from backend.db.chroma import get_all_signals as _gas
        import json as _json
        raised_sigs = _gas(group_id)
        jira_key = None
        for s in raised_sigs:
            if s.get("metadata", {}).get("signal_id") == sig_id:
                try:
                    ents = _json.loads(s["metadata"].get("entities", "[]"))
                except Exception:
                    ents = []
                jira_key = ents[0] if ents else None
                break
        if jira_key:
            res = await assign_issue(jira_key, account_id)
            if res.get("ok"):
                from backend.config import JIRA_BASE_URL
                await update.message.reply_text(
                    f"✅ [{jira_key}](https://{JIRA_BASE_URL}/browse/{jira_key}) assigned to *{assignee_name}*",
                    parse_mode="Markdown",
                )
            else:
                await update.message.reply_text(
                    f"❌ Could not assign {jira_key}: {res.get('error')}", parse_mode="Markdown"
                )
            return

    # Raise a new ticket with the assignee baked in
    sig = {
        "id": sig_id,
        "type": meta.get("type", ""),
        "summary": meta.get("summary", ""),
        "severity": meta.get("severity", "high"),
        "raw_quote": best.get("document", ""),
        "entities": meta.get("entities", []),
        "keywords": meta.get("keywords", []),
        "timestamp": meta.get("timestamp", ""),
        "group_id": group_id,
        "lens": meta.get("lens", ""),
        "assignee_override": assignee_name,
    }
    result = await raise_ticket_for_signal(sig, group_id, assignee_account_id=account_id)

    if result.get("ok"):
        await update.message.reply_text(
            f"✅ [{result['key']}]({result['url']}) raised and assigned to *{assignee_name}*\n"
            f"_{result.get('summary', '')[:90]}_",
            parse_mode="Markdown",
        )
    else:
        reason = result.get("reason", "unknown")
        await update.message.reply_text(
            f"❌ Failed to raise ticket: {result.get('error', reason)}", parse_mode="Markdown"
        )


async def _handle_ask_jira_raise(update, context, question: str, group_id: str):
    """
    Called from cmd_ask when a Jira raise intent is detected.
    Finds signals matching the topic in the query, applies priority override from
    keywords (priority 0 / p0 / critical → Highest; priority / urgent / p1 → High),
    then raises Jira tickets and reports results.
    """
    import re
    from backend.integrations.jira_client import is_configured
    from backend.agents.jira_agent import (
        raise_ticket_for_signal,
        RAISEABLE_TYPES,
        format_raise_result_for_telegram,
        SEVERITY_TO_PRIORITY,
    )
    from backend.db.chroma import query_signals, get_all_signals, get_raised_signal_ids
    from backend.config import JIRA_DEFAULT_PROJECT

    if not is_configured():
        await update.message.reply_text(
            "⚙️ Jira is not configured. Add `JIRA_BASE_URL`, `JIRA_EMAIL`, and `JIRA_API_TOKEN` "
            "to your .env and restart.",
            parse_mode="Markdown",
        )
        return

    # ── Determine priority override from keywords in the query ────────────────
    q_lower = question.lower()
    if any(kw in q_lower for kw in ("priority 0", "p0", "critical", "blocker")):
        priority_override = "Highest"
    elif any(kw in q_lower for kw in ("priority 1", "p1", "urgent", "high priority")):
        priority_override = "High"
    elif "priority" in q_lower:
        # Generic "priority" keyword without a level → treat as High
        priority_override = "High"
    else:
        priority_override = None  # Use each signal's own severity

    # ── Extract the topic by stripping the raise intent phrase ────────────────
    _STRIP_PATTERNS = [
        r"raise jira (token|ticket|tickets)?\s*(on|for|about|regarding)?\s*(the\s*)?",
        r"jira raise\s*(on|for|about|regarding)?\s*(the\s*)?",
        r"create jira (ticket|tickets)?\s*(on|for|about|regarding)?\s*(the\s*)?",
        r"file jira (ticket|tickets)?\s*(on|for|about|regarding)?\s*(the\s*)?",
        r"open jira (ticket|tickets)?\s*(on|for|about|regarding)?\s*(the\s*)?",
        r"raise (a\s*)?(jira\s*)?(ticket|tickets)?\s*(on|for|about|regarding)?\s*(the\s*)?",
        r"create (a\s*)?ticket\s*(on|for|about|regarding)?\s*(the\s*)?",
    ]
    topic = q_lower
    for pattern in _STRIP_PATTERNS:
        topic = re.sub(pattern, "", topic, flags=re.IGNORECASE).strip()
    topic = topic.strip(" .,!?") or "priority fixes"

    # ── Flush pending buffer so we see the latest messages ────────────────────
    if _buffers.get(group_id):
        batch = _buffers[group_id]
        _buffers[group_id] = []
        if group_id in _flush_timers:
            _flush_timers[group_id].cancel()
            del _flush_timers[group_id]
        try:
            await process_message_batch(group_id, batch)
        except Exception as e:
            logger.warning(f"Pre-ask-jira flush failed for {group_id}: {e}")

    await update.message.reply_text(
        "🔍 Searching signals to raise...", parse_mode="Markdown"
    )

    # ── Find raiseable signals matching the topic ──────────────────────────────
    already_raised = get_raised_signal_ids(group_id)

    # Semantic search on topic
    semantic_hits = query_signals(group_id, topic, n_results=10)
    candidates = [
        r
        for r in semantic_hits
        if r.get("metadata", {}).get("type") in RAISEABLE_TYPES
        and r.get("id", "") not in already_raised
    ]

    # Fallback: if semantic search found nothing, use all unraised raiseable signals
    if not candidates:
        all_sigs = get_all_signals(group_id)
        candidates = [
            {"id": s["id"], "document": s["document"], "metadata": s["metadata"]}
            for s in all_sigs
            if s.get("metadata", {}).get("type") in RAISEABLE_TYPES
            and s.get("id", "") not in already_raised
        ][:5]

    if not candidates:
        await update.message.reply_text(
            f"📭 No raiseable signals found for *{topic}* in this group.\n\n"
            "Make sure conversations have been processed first, or use `/jira` to see "
            "all pending signals.",
            parse_mode="Markdown",
        )
        return

    prio_label = f" with *{priority_override}* priority" if priority_override else ""
    await update.message.reply_text(
        f"🚀 Raising {len(candidates)} ticket(s){prio_label} for: _{topic}_",
        parse_mode="Markdown",
    )

    # ── Raise each ticket ─────────────────────────────────────────────────────
    _rev_priority = {
        "Highest": "critical",
        "High": "high",
        "Medium": "medium",
        "Low": "low",
    }
    results = []
    for r in candidates:
        meta = r.get("metadata", {})
        sig = {
            "id": r.get("id", ""),
            "type": meta.get("type", ""),
            "summary": meta.get("summary", ""),
            "severity": meta.get("severity", "medium"),
            "raw_quote": r.get("document", ""),
            "entities": meta.get("entities", []),
            "keywords": meta.get("keywords", []),
            "timestamp": meta.get("timestamp", ""),
            "group_id": group_id,
            "lens": meta.get("lens", ""),
        }
        if priority_override:
            sig["severity"] = _rev_priority.get(priority_override, "high")

        result = await raise_ticket_for_signal(sig, group_id)
        results.append(
            {
                **result,
                "signal_type": sig["type"],
                "signal_summary": sig["summary"][:80],
            }
        )

    raised = [r for r in results if r.get("ok")]
    failed = [
        r
        for r in results
        if not r.get("ok")
        and r.get("reason") not in ("already_raised", "not_raiseable")
    ]

    lines = [f"🎫 *Jira Tickets Raised* ({len(raised)}/{len(candidates)})\n"]
    for r in results:
        lines.append(format_raise_result_for_telegram(r))
    if failed:
        lines.append(f"\n⚠️ {len(failed)} failed — check logs for details")
    if not raised and not failed:
        lines.append("⏭️ All matching signals were already raised or not raiseable.")

    await update.message.reply_text("\n".join(lines), parse_mode="Markdown")


async def cmd_flush(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Manually flush buffered messages for immediate processing."""
    group_id = str(update.message.chat_id)

    if group_id not in _buffers or not _buffers[group_id]:
        await update.message.reply_text("✅ No messages in buffer (already processed)")
        return

    batch = _buffers[group_id]
    _buffers[group_id] = []

    # Cancel any pending timer
    if group_id in _flush_timers:
        _flush_timers[group_id].cancel()
        del _flush_timers[group_id]

    await update.message.reply_text(
        f"⚡ Processing {len(batch)} buffered message(s)..."
    )

    try:
        signals = await process_message_batch(group_id, batch)
        if signals:
            await update.message.reply_text(
                f"✅ Processed {len(batch)} messages → {len(signals)} signals extracted.\nYou can now `/ask` questions about them.",
                parse_mode="Markdown",
            )
            logger.info(
                f"Manual flush: {len(signals)} signals from {_group_names.get(group_id, group_id)}"
            )
        else:
            await update.message.reply_text(
                "✅ Messages processed (no significant signals detected)"
            )
    except Exception as e:
        logger.error(f"Manual flush failed: {e}")
        await update.message.reply_text(f"❌ Processing failed: {str(e)[:100]}")


async def cmd_debug(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show recent signals for debugging."""
    group_id = str(update.message.chat_id)
    from backend.db.chroma import get_all_signals
    import json

    signals = get_all_signals(group_id)

    if not signals:
        await update.message.reply_text("No signals found for this group yet.")
        return

    # Show last 5 signals
    lines = [f"🔍 *Debug: Last 5 Signals*\n"]

    for sig in signals[-5:]:
        meta = sig.get("metadata", {})
        doc = sig.get("document", "")

        sig_type = meta.get("type", "unknown")
        timestamp = meta.get("timestamp", "")[:16]  # Just date+time

        # Extract summary from document
        if ": " in doc:
            summary = doc.split(": ", 1)[1].split(" | Quote:")[0]
        else:
            summary = doc

        lines.append(f"• [{sig_type}] {timestamp}")
        lines.append(f"  {summary[:100]}...\n")

    await update.message.reply_text("\n".join(lines), parse_mode="Markdown")


async def cmd_digest(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Generate a summary digest."""
    group_id = str(update.message.chat_id)
    from backend.db.chroma import get_all_signals

    signals = get_all_signals(group_id)
    if not signals:
        await update.message.reply_text(
            "No intelligence gathered yet. I need more conversation to learn from!"
        )
        return

    # Group by type
    by_type = defaultdict(list)
    for s in signals:
        by_type[s["metadata"].get("type", "other")].append(s)

    parts = [f"📊 *Intelligence Digest* ({len(signals)} total signals)\n"]
    for sig_type, sigs in sorted(by_type.items(), key=lambda x: -len(x[1])):
        parts.append(f"• {sig_type.replace('_', ' ').title()}: {len(sigs)} signals")

    await update.message.reply_text("\n".join(parts))


async def cmd_lens(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Set or check the active lens."""
    group_id = str(update.message.chat_id)

    if context.args:
        mode = context.args[0].lower()
        if mode in ("dev", "product", "client", "community", "auto"):
            set_lens(group_id, mode)
            await update.message.reply_text(f"🔭 Lens set to: {mode}")
        else:
            await update.message.reply_text(
                "Valid lenses: dev, product, client, community, auto"
            )
    else:
        current = get_lens(group_id)
        await update.message.reply_text(f"🔭 Current lens: {current}")


async def cmd_search(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Handle /search [query] — explicit web search."""
    if not ENABLE_WEB_SEARCH:
        await update.message.reply_text("🔍 Web search is currently disabled.")
        return

    if not context.args:
        await update.message.reply_text(
            "Usage: /search [your query]\nExample: /search FastAPI rate limiting best practices"
        )
        return

    query = " ".join(context.args)
    await update.message.reply_text(f"🌐 Searching the web for: {query}...")

    try:
        results = await search_web(query, max_results=3)
        if not results:
            await update.message.reply_text(
                "No web results found. Try a different query."
            )
            return

        parts = [f"🌐 Web Search: {query}\n"]
        for i, r in enumerate(results):
            snippet = (
                r["content"][:200] + "..." if len(r["content"]) > 200 else r["content"]
            )
            parts.append(f"{i+1}. {r['title']}\n{snippet}\n🔗 {r['url']}\n")

        await update.message.reply_text("\n".join(parts))

    except Exception as e:
        await update.message.reply_text(f"Search failed: {str(e)[:100]}")


async def cmd_start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Welcome message."""
    await update.message.reply_text(
        "👁️ *ThirdEye* — Conversation Intelligence Engine\n\n"
        "I'm now listening to this group and extracting intelligence from your conversations.\n\n"
        "Commands:\n"
        "/ask [question] — Ask about your team's knowledge\n"
        "   ↳ /ask raise jira on [topic] — raise Jira tickets matching a topic\n"
        "   ↳ /ask raise jira on priority fixes — raises as High priority automatically\n"
        "   ↳ /ask assign jira ticket for [topic] to [Name] — raise & assign to a person\n"
        "/search [query] — Search the web for external info\n"
        "/digest — Get an intelligence summary\n"
        "/lens [mode] — Set detection mode (dev/product/client/community)\n"
        "/alerts — View active warnings\n"
        "/flush — Process buffered messages now\n"
        "/debug — Show last 5 signals\n\n"
        "📄 Share documents (PDF, DOCX, TXT) — I'll ingest them into the knowledge base.\n"
        "🔗 Share links — I'll fetch and store their content.\n\n"
        "🎙️ /meetsum [id] — Summarize a meeting\n"
        "🔍 /meetask [id] [q] — Ask about a meeting\n"
        "🔗 /meetmatch [id] — Match meeting to team chats\n"
        "🎫 /jira — Preview & raise Jira tickets from signals\n"
        "📋 /jirastatus [KEY] — Get ticket status (e.g. ENG-42)\n"
        "🔍 /jirasearch [query] — Search Jira in plain English\n"
        "📜 /jiraraised — See all tickets ThirdEye has raised\n"
        "👁️ /jirawatch [on|off] — Toggle auto-raise mode\n\n"
        "🎤 /voicelog — Audit trail of all voice note decisions\n"
        "🎤 /voicelog @name — Voice notes by a specific person\n"
        "🎤 /voicelog decisions|actions|blockers — Filter by type\n"
        "🎤 /voicelog search [q] — Search voice note content\n\n"
        "I work passively — no need to tag me. I'll alert you when I spot patterns or issues.",
        parse_mode=None,
    )


# ─────────────────────────────────────────────
#  Meet Commands — add to existing commands.py
# ─────────────────────────────────────────────


async def cmd_meetsum(update, context):
    """
    /meetsum [meeting_id]
    Summarizes a meeting. Uses the most recent meeting if no ID given.
    """
    from backend.db.chroma import query_signals
    from backend.config import MEET_DEFAULT_GROUP_ID

    args = context.args or []
    group_id = MEET_DEFAULT_GROUP_ID

    if args:
        meeting_id = args[0]
    else:
        # Find the most recent meeting ID from meet_summary signals
        all_summaries = query_signals(
            group_id, "meeting summary", n_results=5, signal_type="meet_summary"
        )
        if not all_summaries:
            await update.message.reply_text(
                "📭 No meeting summaries found yet. Record a meeting with the ThirdEye Meet extension first."
            )
            return
        # The most recent signal (by position in results, or pick first)
        meeting_id = all_summaries[0].get("metadata", {}).get("meeting_id", "unknown")

    if not meeting_id or meeting_id == "unknown":
        await update.message.reply_text("Usage: /meetsum [meeting_id]")
        return

    # Fetch summary signal
    signals = query_signals(group_id, meeting_id, n_results=20)
    summary_signal = next(
        (s for s in signals if s.get("metadata", {}).get("type") == "meet_summary"),
        None,
    )

    if summary_signal:
        # Summary text is in the document field
        summary_text = summary_signal.get("metadata", {}).get(
            "raw_quote", ""
        ) or summary_signal.get("document", "")
        await update.message.reply_text(
            f"📋 *Meeting Summary*\nID: `{meeting_id}`\n\n{summary_text}",
            parse_mode="Markdown",
        )
        return

    # No summary yet — gather structured signals and summarize on-the-fly
    structured = [
        s
        for s in signals
        if s.get("metadata", {}).get("type")
        in ("meet_decision", "meet_action_item", "meet_blocker", "meet_risk")
    ]

    if not structured:
        await update.message.reply_text(
            f"📭 No signals found for meeting `{meeting_id}`. "
            "Make sure the meeting has been recorded and processed.",
            parse_mode="Markdown",
        )
        return

    lines = [f"📋 *Meeting Signals* for `{meeting_id}`\n"]
    type_labels = {
        "meet_decision": "✅ Decision",
        "meet_action_item": "📌 Action",
        "meet_blocker": "🚧 Blocker",
        "meet_risk": "⚠️ Risk",
    }
    for s in structured[:10]:
        sig_type = s.get("metadata", {}).get("type", "unknown")
        label = type_labels.get(sig_type, sig_type)
        # Get summary from document text (format: "type: summary | Quote: ...")
        doc = s.get("document", "")
        if ": " in doc:
            summary = doc.split(": ", 1)[1].split(" | Quote:")[0]
        else:
            summary = doc
        lines.append(f"{label}: {summary[:120]}")

    await update.message.reply_text("\n".join(lines), parse_mode="Markdown")


async def cmd_meetask(update, context):
    """
    /meetask [meeting_id] [question]
    Asks a question about a specific meeting's knowledge.
    """
    from backend.pipeline import query_knowledge
    from backend.config import MEET_DEFAULT_GROUP_ID

    args = context.args or []
    if len(args) < 2:
        await update.message.reply_text(
            "Usage: /meetask [meeting_id] [your question]\n"
            "Example: /meetask abc-defg-hij What did we decide about the database?"
        )
        return

    meeting_id = args[0]
    question = " ".join(args[1:])
    group_id = MEET_DEFAULT_GROUP_ID

    await update.message.reply_text(
        f"🔍 Searching meeting `{meeting_id}`...", parse_mode="Markdown"
    )

    # Augment the question with meeting ID context so the RAG retrieval is scoped
    scoped_question = f"From meeting {meeting_id}: {question}"
    answer = await query_knowledge(group_id, scoped_question)

    await update.message.reply_text(
        f"🎙️ *Meet Q&A* — `{meeting_id}`\n\nQ: _{question}_\n\nA: {answer}",
        parse_mode="Markdown",
    )


async def cmd_meetmatch(update, context):
    """
    /meetmatch [meeting_id]
    Finds where a meeting's decisions/blockers match or conflict with your team chat signals.
    """
    from backend.agents.meet_cross_ref import (
        find_cross_references,
        format_cross_ref_for_telegram,
    )
    from backend.db.chroma import query_signals
    from backend.config import MEET_DEFAULT_GROUP_ID

    args = context.args or []
    group_id = MEET_DEFAULT_GROUP_ID

    if args:
        meeting_id = args[0]
    else:
        # Find most recent meeting
        all_summaries = query_signals(
            group_id, "meeting", n_results=5, signal_type="meet_summary"
        )
        if not all_summaries:
            await update.message.reply_text(
                "📭 No meetings found. Record a meeting first with the ThirdEye Meet extension."
            )
            return
        meeting_id = all_summaries[0].get("metadata", {}).get("meeting_id", "unknown")

    await update.message.reply_text(
        f"🔗 Comparing meeting `{meeting_id}` against your team chats...\n"
        "_This may take a moment._",
        parse_mode="Markdown",
    )

    analysis = await find_cross_references(meeting_id, group_id=group_id)
    formatted = format_cross_ref_for_telegram(analysis, meeting_id)
    await update.message.reply_text(formatted, parse_mode="Markdown")


# ─────────────────────────────────────────────
#  Jira Commands — add to existing commands.py
# ─────────────────────────────────────────────


async def cmd_jira(update, context):
    """
    /jira
    Shows unraised high-severity signals in this group and raises them as Jira tickets.
    With no args: shows a preview of what would be raised and asks for confirmation.
    With 'confirm': actually raises the tickets.

    Usage:
      /jira            — preview unraised signals
      /jira confirm    — raise all unraised high+ severity signals now
      /jira [signal_type]  — raise only signals of that type (e.g. /jira recurring_bug)
    """
    from backend.db.chroma import get_all_signals, get_raised_signal_ids
    from backend.agents.jira_agent import (
        bulk_raise_for_group,
        RAISEABLE_TYPES,
        SEVERITY_TO_PRIORITY,
        format_raise_result_for_telegram,
    )
    from backend.integrations.jira_client import is_configured
    from backend.config import JIRA_DEFAULT_PROJECT

    chat_id = str(update.effective_chat.id)
    args = context.args or []
    confirm = "confirm" in [a.lower() for a in args]
    type_filter = next(
        (a for a in args if a.lower() not in ("confirm",) and "_" in a), None
    )

    if not is_configured():
        await update.message.reply_text(
            "⚙️ Jira is not configured. Add `JIRA_BASE_URL`, `JIRA_EMAIL`, and `JIRA_API_TOKEN` to your .env and restart."
        )
        return

    await update.message.reply_text("🔍 Scanning signals...", parse_mode="Markdown")

    all_signals = get_all_signals(chat_id)
    already_raised = get_raised_signal_ids(chat_id)
    severity_rank = {"low": 0, "medium": 1, "high": 2, "critical": 3}

    candidates = [
        s
        for s in all_signals
        if s.get("type") in RAISEABLE_TYPES
        and s.get("id", "") not in already_raised
        and severity_rank.get(s.get("severity", "low"), 0) >= 2  # high+
        and (not type_filter or s.get("type") == type_filter)
    ]

    if not candidates:
        await update.message.reply_text(
            "✅ Nothing to raise — no unraised high-severity signals found in this group.\n"
            "Use `/ask` to query existing knowledge or wait for new signals.",
            parse_mode="Markdown",
        )
        return

    if not confirm:
        # Preview mode — show what would be raised
        lines = [
            f"📋 *{len(candidates)} signal(s) ready to raise in `{JIRA_DEFAULT_PROJECT}`*\n"
        ]
        for s in candidates[:8]:
            lines.append(
                f"• [{s.get('severity','?').upper()}] `{s.get('type','?')}` — "
                f"_{s.get('summary','')[:80]}_"
            )
        if len(candidates) > 8:
            lines.append(f"_...and {len(candidates) - 8} more_")
        lines.append(f"\nSend `/jira confirm` to raise all of these as Jira tickets.")
        await update.message.reply_text("\n".join(lines), parse_mode="Markdown")
        return

    # Confirm mode — raise the tickets
    await update.message.reply_text(
        f"🚀 Raising {len(candidates)} ticket(s) in `{JIRA_DEFAULT_PROJECT}`...",
        parse_mode="Markdown",
    )
    results = await bulk_raise_for_group(
        group_id=chat_id,
        signals=candidates,
        min_severity="high",
        max_tickets=10,
    )

    raised = [r for r in results if r.get("ok")]
    failed = [
        r
        for r in results
        if not r.get("ok")
        and r.get("reason") not in ("already_raised", "not_raiseable")
    ]

    lines = [f"🎫 *Jira Tickets Raised* ({len(raised)}/{len(candidates)})\n"]
    for r in raised:
        lines.append(format_raise_result_for_telegram(r))
    if failed:
        lines.append(f"\n⚠️ {len(failed)} failed — check logs")

    await update.message.reply_text("\n".join(lines), parse_mode="Markdown")


async def cmd_jirastatus(update, context):
    """
    /jirastatus [TICKET-KEY]
    Get the current status of a specific Jira ticket.

    Usage:
      /jirastatus ENG-42
    """
    from backend.integrations.jira_client import get_issue, is_configured

    if not is_configured():
        await update.message.reply_text("⚙️ Jira not configured.")
        return

    args = context.args or []
    if not args:
        await update.message.reply_text(
            "Usage: `/jirastatus TICKET-KEY`\nExample: `/jirastatus ENG-42`",
            parse_mode="Markdown",
        )
        return

    issue_key = args[0].upper()
    try:
        issue = await get_issue(issue_key)
        status_emoji = {
            "To Do": "🔵",
            "In Progress": "🟡",
            "Done": "✅",
            "Blocked": "🔴",
        }.get(issue["status"], "⚪")
        msg = (
            f"🎫 *{issue['key']}*\n"
            f"{status_emoji} Status: *{issue['status']}*\n"
            f"📌 Type: {issue['issue_type']} | ⚡ Priority: {issue['priority']}\n"
            f"👤 Assignee: {issue['assignee']}\n"
            f"📝 {issue['summary']}\n\n"
            f"🔗 [Open in Jira]({issue['url']})"
        )
        await update.message.reply_text(msg, parse_mode="Markdown")
    except Exception as e:
        await update.message.reply_text(
            f"❌ Could not fetch `{issue_key}`: {e}", parse_mode="Markdown"
        )


async def cmd_jirasearch(update, context):
    """
    /jirasearch [query]
    Search Jira using natural language. ThirdEye converts it to JQL automatically.

    Usage:
      /jirasearch open bugs assigned to Alex
      /jirasearch all thirdeye tickets from this sprint
    """
    from backend.integrations.jira_client import search_issues, is_configured
    from backend.providers import call_llm
    from backend.config import JIRA_DEFAULT_PROJECT

    if not is_configured():
        await update.message.reply_text("⚙️ Jira not configured.")
        return

    args = context.args or []
    if not args:
        await update.message.reply_text(
            "Usage: `/jirasearch [natural language query]`\n"
            "Example: `/jirasearch open bugs assigned to Alex`",
            parse_mode="Markdown",
        )
        return

    query = " ".join(args)
    await update.message.reply_text(
        f"🔍 Searching Jira for: _{query}_...", parse_mode="Markdown"
    )

    # Convert natural language → JQL via LLM
    try:
        jql_result = await call_llm(
            task_type="fast_small",
            messages=[
                {
                    "role": "system",
                    "content": (
                        f"Convert the user's natural language query into a valid Jira JQL query. "
                        f"Default project is '{JIRA_DEFAULT_PROJECT}'. "
                        "Return ONLY the JQL string — no explanation, no quotes around it, no markdown."
                    ),
                },
                {"role": "user", "content": query},
            ],
            temperature=0.0,
            max_tokens=150,
        )
        jql = jql_result["content"].strip().strip('"').strip("'")
    except Exception:
        # Fallback: simple text search JQL
        jql = f'project = {JIRA_DEFAULT_PROJECT} AND text ~ "{query}" ORDER BY created DESC'

    try:
        results = await search_issues(jql, max_results=8)
    except Exception as e:
        await update.message.reply_text(
            f"❌ JQL search failed.\nJQL used: `{jql}`\nError: {e}",
            parse_mode="Markdown",
        )
        return

    if not results:
        await update.message.reply_text(
            f"📭 No results found.\nJQL: `{jql}`",
            parse_mode="Markdown",
        )
        return

    status_emoji = {"To Do": "🔵", "In Progress": "🟡", "Done": "✅"}.get
    lines = [f"🔍 *Jira Search Results* ({len(results)} found)\nQuery: _{query}_\n"]
    for r in results:
        emoji = {"To Do": "🔵", "In Progress": "🟡", "Done": "✅"}.get(
            r["status"], "⚪"
        )
        lines.append(
            f"{emoji} [{r['key']}]({r['url']}) — _{r['summary'][:70]}_\n"
            f"   {r['status']} | {r['priority']} | {r['assignee']}"
        )
    await update.message.reply_text("\n".join(lines), parse_mode="Markdown")


async def cmd_jiraraised(update, context):
    """
    /jiraraised
    Shows all tickets ThirdEye has previously raised for this group.
    """
    from backend.db.chroma import query_signals
    from backend.integrations.jira_client import is_configured
    from backend.config import JIRA_BASE_URL

    if not is_configured():
        await update.message.reply_text("⚙️ Jira not configured.")
        return

    chat_id = str(update.effective_chat.id)
    raised_signals = query_signals(
        chat_id, "jira raised ticket", n_results=20, signal_type="jira_raised"
    )

    if not raised_signals:
        await update.message.reply_text(
            "📭 No tickets raised yet for this group. Use `/jira confirm` to raise tickets.",
            parse_mode="Markdown",
        )
        return

    lines = [f"🎫 *Tickets Raised by ThirdEye* ({len(raised_signals)} total)\n"]
    for sig in raised_signals[:10]:
        meta = sig.get("metadata", {})
        # entities is stored as a JSON string in ChromaDB metadata
        try:
            import json as _json
            entities_raw = meta.get("entities", "[]")
            entities = _json.loads(entities_raw) if isinstance(entities_raw, str) else (entities_raw or [])
        except Exception:
            entities = []
        jira_key = entities[0] if entities else "Unknown"
        url = f"{JIRA_BASE_URL}/browse/{jira_key}"
        label = meta.get("summary", "") or sig.get("document", "")
        lines.append(f"• [{jira_key}]({url}) — _{label[:80]}_")

    if len(raised_signals) > 10:
        lines.append(f"_...and {len(raised_signals) - 10} more_")

    await update.message.reply_text("\n".join(lines), parse_mode="Markdown")


async def cmd_jirawatch(update, context):
    """
    /jirawatch [on|off]
    Enable or disable auto-raise mode for this group.
    When ON: any new signal at or above JIRA_AUTO_RAISE_SEVERITY is automatically
    filed as a Jira ticket without manual /jira confirm.

    Usage:
      /jirawatch on
      /jirawatch off
      /jirawatch        — show current status
    """
    import json
    from telegram.ext import ContextTypes

    args = context.args or []
    chat_id = str(update.effective_chat.id)

    # Store watch state in bot_data (in-memory; persists until restart)
    if not hasattr(context, "bot_data"):
        context.bot_data = {}
    watch_key = f"jirawatch_{chat_id}"

    if not args:
        current = context.bot_data.get(watch_key, False)
        status = "🟢 ON" if current else "🔴 OFF"
        await update.message.reply_text(
            f"👁️ *Jira Auto-Raise* — {status}\n\n"
            "When ON, ThirdEye automatically raises Jira tickets for any high or critical "
            "severity signal detected in this group — no `/jira confirm` needed.\n\n"
            "Use `/jirawatch on` or `/jirawatch off` to toggle.",
            parse_mode="Markdown",
        )
        return

    mode = args[0].lower()
    if mode == "on":
        context.bot_data[watch_key] = True
        await update.message.reply_text(
            "🟢 *Jira Auto-Raise: ON*\n"
            "Any new `high` or `critical` signal detected in this group will automatically "
            "be raised as a Jira ticket. You'll be notified here.\n\n"
            "Use `/jirawatch off` to disable.",
            parse_mode="Markdown",
        )
    elif mode == "off":
        context.bot_data[watch_key] = False
        await update.message.reply_text(
            "🔴 *Jira Auto-Raise: OFF*\n"
            "Use `/jira confirm` to raise tickets manually.",
            parse_mode="Markdown",
        )
    else:
        await update.message.reply_text(
            "Usage: `/jirawatch on` or `/jirawatch off`", parse_mode="Markdown"
        )


# -----------------------------------------------------------------
#  Voice Message Handlers — add to commands.py
# -----------------------------------------------------------------


async def handle_voice_telegram(update, context):
    """
    Fires for every voice message sent to a monitored group.
    Downloads, transcribes via Groq Whisper, feeds into signal pipeline.
    """
    from backend.agents.voice_handler import handle_voice_message
    from backend.config import ENABLE_VOICE_TRANSCRIPTION

    if not ENABLE_VOICE_TRANSCRIPTION:
        return

    msg = update.message
    if not msg or not msg.voice:
        return

    group_id = str(msg.chat_id)
    sender = msg.from_user.full_name or msg.from_user.username or "Unknown"
    voice = msg.voice
    duration = voice.duration or 0

    # React with 👂 immediately so team knows ThirdEye is processing
    try:
        await msg.set_reaction("👂")
    except Exception:
        pass  # Reactions need bot admin rights — fail silently

    result = await handle_voice_message(
        bot=context.bot,
        group_id=group_id,
        sender=sender,
        file_id=voice.file_id,
        duration_seconds=duration,
        message_date=msg.date,
        is_video_note=False,
    )

    if result["ok"]:
        signals = result["signals_extracted"]
        reply = (
            f"🎤 *{sender}* ({duration}s) — transcribed\n"
            f"_{result['transcript'][:120]}{'...' if len(result['transcript']) > 120 else ''}_\n"
            f"`{signals} signal{'s' if signals != 1 else ''} extracted`"
        )
        await msg.reply_text(reply, parse_mode="Markdown")
    elif result["reason"] == "too_long":
        await msg.reply_text(
            f"⏭️ Voice note from *{sender}* skipped — too long ({duration}s).",
            parse_mode="Markdown",
        )
    elif result["reason"] in ("no_speech", "too_short", "empty"):
        pass  # Silent skip
    else:
        logger.warning(f"Voice error for {sender}: {result.get('error')}")


async def handle_video_note_telegram(update, context):
    """
    Fires for round video messages (video notes).
    Same pipeline as voice messages — also contain audio.
    """
    from backend.agents.voice_handler import handle_voice_message
    from backend.config import ENABLE_VOICE_TRANSCRIPTION

    if not ENABLE_VOICE_TRANSCRIPTION:
        return

    msg = update.message
    if not msg or not msg.video_note:
        return

    group_id = str(msg.chat_id)
    sender = msg.from_user.full_name or msg.from_user.username or "Unknown"
    video_note = msg.video_note
    duration = video_note.duration or 0

    try:
        await msg.set_reaction("👂")
    except Exception:
        pass

    result = await handle_voice_message(
        bot=context.bot,
        group_id=group_id,
        sender=sender,
        file_id=video_note.file_id,
        duration_seconds=duration,
        message_date=msg.date,
        is_video_note=True,
    )

    if result["ok"]:
        signals = result["signals_extracted"]
        reply = (
            f"📹 *{sender}* ({duration}s video note) — transcribed\n"
            f"_{result['transcript'][:120]}{'...' if len(result['transcript']) > 120 else ''}_\n"
            f"`{signals} signal{'s' if signals != 1 else ''} extracted`"
        )
        await msg.reply_text(reply, parse_mode="Markdown")


def run_bot():
    """Start the Telegram bot."""
    from telegram.request import HTTPXRequest

    # Configure longer timeouts for slow network or heavy processing
    request = HTTPXRequest(
        connection_pool_size=8,
        connect_timeout=20.0,
        read_timeout=30.0,
        write_timeout=30.0,
        pool_timeout=10.0,
    )

    app = Application.builder().token(TELEGRAM_BOT_TOKEN).request(request).build()

    app.add_handler(CommandHandler("start", cmd_start))
    app.add_handler(CommandHandler("ask", cmd_ask))
    app.add_handler(CommandHandler("digest", cmd_digest))
    app.add_handler(CommandHandler("lens", cmd_lens))
    app.add_handler(CommandHandler("flush", cmd_flush))
    app.add_handler(CommandHandler("debug", cmd_debug))
    app.add_handler(MessageHandler(filters.Document.ALL, handle_document))
    app.add_handler(CommandHandler("search", cmd_search))
    app.add_handler(CommandHandler("meetsum", cmd_meetsum))
    app.add_handler(CommandHandler("meetask", cmd_meetask))
    app.add_handler(CommandHandler("meetmatch", cmd_meetmatch))
    app.add_handler(CommandHandler("jira", cmd_jira))
    app.add_handler(CommandHandler("jirastatus", cmd_jirastatus))
    app.add_handler(CommandHandler("jirasearch", cmd_jirasearch))
    app.add_handler(CommandHandler("jiraraised", cmd_jiraraised))
    app.add_handler(CommandHandler("jirawatch", cmd_jirawatch))

    from backend.bot.commands import cmd_voicelog
    app.add_handler(CommandHandler("voicelog", cmd_voicelog))

    app.add_handler(
        MessageHandler(filters.VOICE & ~filters.COMMAND, handle_voice_telegram)
    )
    app.add_handler(
        MessageHandler(
            filters.VIDEO_NOTE & ~filters.COMMAND, handle_video_note_telegram
        )
    )

    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))

    logger.info("ThirdEye bot starting...")
    app.run_polling(allowed_updates=Update.ALL_TYPES)


if __name__ == "__main__":
    run_bot()