main.py

# main.py (Revised with Starlette-only routes and fixes)
import os
import re
import logging
import asyncio
import json
import html
import contextlib
import traceback
from typing import Optional, Dict, Any

# --- Frameworks ---
# Removed Flask imports
from starlette.applications import Starlette
from starlette.routing import Route # Changed from Mount
from starlette.responses import PlainTextResponse, JSONResponse, Response # Starlette responses
from starlette.requests import Request # Starlette request object

# --- Telegram Bot ---
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup, Bot
from telegram.ext import (
    Application,
    CommandHandler,
    MessageHandler,
    filters,
    ContextTypes,
    CallbackQueryHandler,
)
from telegram.constants import ParseMode
from telegram.error import NetworkError, RetryAfter, TimedOut, BadRequest, TelegramError
from telegram.request import HTTPXRequest

# --- Other Libraries ---
import httpx
from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
import requests
from bs4 import BeautifulSoup
from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type, before_sleep_log

_apify_token_exists = bool(os.environ.get('APIFY_API_TOKEN'))
if _apify_token_exists:
    from apify_client import ApifyClient
    from apify_client.consts import ActorJobStatus
else:
    ApifyClient = None # type: ignore # Make type checkers happy


# --- Logging Setup ---
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO # Changed default to INFO, DEBUG is very verbose
)
logging.getLogger("httpx").setLevel(logging.WARNING)
if ApifyClient: logging.getLogger("apify_client").setLevel(logging.WARNING)
logging.getLogger("telegram.ext").setLevel(logging.INFO)
logging.getLogger('telegram.bot').setLevel(logging.INFO)
logging.getLogger("urllib3").setLevel(logging.INFO)
logging.getLogger('gunicorn.error').setLevel(logging.INFO)
logging.getLogger('uvicorn').setLevel(logging.INFO)
logging.getLogger('starlette').setLevel(logging.INFO)
logger = logging.getLogger(__name__)
logger.info("Logging configured.")

# --- Global variable for PTB app ---
ptb_app: Optional[Application] = None

# --- Environment Variable Loading ---
logger.info("Attempting to load secrets...")
def get_secret(secret_name):
    value = os.environ.get(secret_name)
    if value: logger.info(f"Secret '{secret_name}': Found (Value length: {len(value)})")
    else: logger.warning(f"Secret '{secret_name}': Not Found")
    return value

TELEGRAM_TOKEN = get_secret('TELEGRAM_TOKEN')
OPENROUTER_API_KEY = get_secret('OPENROUTER_API_KEY')
URLTOTEXT_API_KEY = get_secret('URLTOTEXT_API_KEY')
SUPADATA_API_KEY = get_secret('SUPADATA_API_KEY')
APIFY_API_TOKEN = get_secret('APIFY_API_TOKEN')
logger.info("Secret loading attempt finished.")

# --- Retry Decorator for Bot Operations ---
# Increased attempts slightly and added logging before sleep
# Explicitly catch TelegramError subclasses for retries
@retry(
    stop=stop_after_attempt(4), # Increased slightly
    wait=wait_exponential(multiplier=1, min=2, max=15), # Adjusted wait
    retry=retry_if_exception_type((NetworkError, RetryAfter, TimedOut, BadRequest)), # Specific Telegram errors
    before_sleep=before_sleep_log(logger, logging.WARNING), # Use tenacity logger
    reraise=True # Reraise the exception if all retries fail
)
async def retry_bot_operation(func, *args, **kwargs):
    """Wrapper to retry bot operations with exponential backoff."""
    # Note: This is now a wrapper function, not a decorator factory
    # Call it like: await retry_bot_operation(bot.send_message, chat_id=..., text=...)
    try:
        return await func(*args, **kwargs)
    except BadRequest as e:
        # Don't retry on bad requests that are likely permanent (e.g., chat not found)
        # unless it's a common transient issue like message not modified
        if "message is not modified" in str(e).lower():
            logger.warning(f"Ignoring 'message not modified' error: {e}")
            return None # Or indicate success/no action needed
        logger.error(f"BadRequest during bot operation (will not retry unless specific): {e}")
        raise # Reraise non-retryable BadRequests
    except TelegramError as e:
        logger.warning(f"TelegramError during bot operation (will retry): {e}")
        raise # Reraise retryable errors for tenacity
    except Exception as e:
        logger.error(f"Unexpected error during bot operation: {e}", exc_info=True)
        raise # Reraise unexpected errors

# --- Helper Functions ---
def is_youtube_url(url):
    """Checks if the URL is a valid YouTube video or shorts URL."""
    # More robust regex to handle various youtube domain variations and query params
    youtube_regex = re.compile(
        r'(?:https?://)?(?:www\.)?(?:m\.)?(?:youtube(?:-nocookie)?\.com|youtu\.be)/'
        r'(?:watch\?v=|embed/|v/|shorts/|live/|attribution_link\?a=.*&u=/watch\?v=)?'
        r'([\w-]{11})' # Group 1: Video ID
        r'(?:\S+)?', # Optional non-whitespace characters after ID
        re.IGNORECASE)
    match = youtube_regex.search(url)
    logger.debug(f"is_youtube_url check for '{url}': {'Match found' if match else 'No match'}")
    return bool(match)

def extract_youtube_id(url):
    """Extracts the YouTube video ID from a URL."""
    # Use the same robust regex as is_youtube_url
    youtube_regex = re.compile(
        r'(?:https?://)?(?:www\.)?(?:m\.)?(?:youtube(?:-nocookie)?\.com|youtu\.be)/'
        r'(?:watch\?v=|embed/|v/|shorts/|live/|attribution_link\?a=.*&u=/watch\?v=)?'
        r'([\w-]{11})' # Group 1: Video ID
        r'(?:\S+)?',
        re.IGNORECASE)
    match = youtube_regex.search(url)
    if match:
        video_id = match.group(1)
        logger.debug(f"Extracted YouTube ID '{video_id}' from URL: {url}")
        return video_id
    else:
        logger.warning(f"Could not extract YouTube ID from URL: {url}")
        return None

# --- Content Fetching Functions ---

# Using httpx for async requests
async def fetch_url_content(url: str, timeout: int = 20) -> Optional[str]:
    """Fetches content from a URL using httpx asynchronously."""
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
    }
    try:
        async with httpx.AsyncClient(follow_redirects=True, timeout=timeout, headers=headers) as client:
            response = await client.get(url)
            response.raise_for_status()  # Raise an exception for bad status codes
            # Detect encoding, fallback to UTF-8
            response.encoding = response.apparent_encoding or 'utf-8'
            return response.text
    except httpx.HTTPStatusError as e:
        logger.error(f"HTTP error fetching {url}: {e.response.status_code} - {e}")
    except httpx.RequestError as e:
        logger.error(f"Request error fetching {url}: {e}")
    except Exception as e:
        logger.error(f"Unexpected error fetching {url}: {e}", exc_info=True)
    return None

async def get_transcript_via_supadata(video_id: str, api_key: str) -> Optional[str]:
    """Fetches YouTube transcript using Supadata API."""
    if not api_key: return None
    api_url = f"https://api.supadata.net/youtube/transcript?video_id={video_id}"
    headers = {'X-API-Key': api_key, 'Accept': 'application/json'}
    logger.info(f"Attempting transcript fetch via Supadata for {video_id}")
    try:
        async with httpx.AsyncClient(timeout=30.0) as client:
            response = await client.get(api_url, headers=headers)
            response.raise_for_status()
            data = response.json()
            if data and isinstance(data, list) and data[0].get("text"):
                transcript = " ".join([item["text"] for item in data if "text" in item])
                logger.info(f"Supadata transcript fetched successfully for {video_id} (length: {len(transcript)})")
                return transcript
            else:
                logger.warning(f"Supadata response format unexpected or empty for {video_id}: {data}")
                return None
    except httpx.HTTPStatusError as e:
        logger.error(f"Supadata API HTTP error for {video_id}: {e.response.status_code} - {e}")
    except Exception as e:
        logger.error(f"Error fetching transcript via Supadata for {video_id}: {e}", exc_info=True)
    return None

async def get_transcript_via_apify(video_id: str, api_token: str) -> Optional[str]:
    """Fetches YouTube transcript using Apify YouTube Scraper Actor."""
    if not ApifyClient or not api_token: return None
    logger.info(f"Attempting transcript fetch via Apify for {video_id}")
    try:
        client = ApifyClient(api_token)
        actor_call = client.actor("clockworks/youtube-scraper").call(
            run_input={
                "startUrls": [f"https://www.youtube.com/watch?v={video_id}"],
                "maxResultStreams": 0,
                "maxResults": 0,
                "maxResultCommentStreams": 0,
                "proxyConfiguration": {"useApifyProxy": True},
                 "subtitles": True, # Explicitly request subtitles/transcript
                 "extendOutputFunction": 'async ({ data, item, page, request, customData, Apify }) => { return item; }',
            }
        )

        # Wait for the actor run to complete and fetch results
        dataset_items = client.dataset(actor_call["defaultDatasetId"]).list_items().items
        if dataset_items:
             # Look for transcript data within the results
            for item in dataset_items:
                 if 'subtitles' in item and isinstance(item['subtitles'], list) and len(item['subtitles']) > 0:
                     # Combine transcript lines, assuming standard format
                     transcript = " ".join(line.get('text', '') for line in item['subtitles'][0].get('lines', []))
                     if transcript.strip():
                         logger.info(f"Apify transcript fetched successfully for {video_id} (length: {len(transcript)})")
                         return transcript.strip()
            logger.warning(f"Apify run completed for {video_id}, but no transcript found in results.")
        else:
            logger.warning(f"Apify run completed for {video_id}, but dataset was empty.")

    except Exception as e:
        logger.error(f"Error fetching transcript via Apify for {video_id}: {e}", exc_info=True)
    return None


async def get_youtube_transcript(video_id: str, url: str, supadata_key: Optional[str], apify_token: Optional[str]) -> Optional[str]:
    """Tries different methods to get a YouTube transcript."""
    transcript = None

    # 1. Try Supadata API (if key exists)
    if supadata_key:
        transcript = await get_transcript_via_supadata(video_id, supadata_key)
        if transcript: return transcript

    # 2. Try youtube-transcript-api (Direct method)
    logger.info(f"Attempting transcript fetch via youtube-transcript-api for {video_id}")
    try:
        # Run in executor to avoid blocking async loop
        transcript_list = await asyncio.to_thread(YouTubeTranscriptApi.get_transcript, video_id)
        transcript = " ".join([item['text'] for item in transcript_list])
        logger.info(f"youtube-transcript-api transcript fetched successfully for {video_id} (length: {len(transcript)})")
        return transcript
    except (TranscriptsDisabled, NoTranscriptFound):
        logger.warning(f"Transcripts disabled or unavailable via youtube-transcript-api for {video_id}.")
    except Exception as e:
        logger.error(f"Error using youtube-transcript-api for {video_id}: {e}")

    # 3. Try Apify (if token exists and other methods failed)
    if not transcript and apify_token:
         transcript = await get_transcript_via_apify(video_id, apify_token)
         if transcript: return transcript

    logger.warning(f"Failed to retrieve transcript for YouTube video {video_id} using all available methods.")
    return None

async def get_website_content_via_requests(url: str) -> Optional[str]:
    """Fetches and extracts main text content from a website using BeautifulSoup."""
    logger.info(f"Attempting website scrape via requests/BeautifulSoup for: {url}")
    html_content = await fetch_url_content(url)
    if not html_content:
        return None

    try:
        # Run BeautifulSoup parsing in executor thread
        def parse_html(content):
            soup = BeautifulSoup(content, 'html.parser')
            # Remove script and style elements
            for script_or_style in soup(["script", "style", "nav", "footer", "aside"]):
                script_or_style.decompose()
            # Get text, strip whitespace, join lines
            text = soup.get_text(separator='\n', strip=True)
            lines = (line.strip() for line in text.splitlines())
            chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
            text = '\n'.join(chunk for chunk in chunks if chunk)
            return text

        text_content = await asyncio.to_thread(parse_html, html_content)

        if text_content and len(text_content) > 100: # Basic check for meaningful content
            logger.info(f"Successfully scraped content via requests/BeautifulSoup for {url} (length: {len(text_content)})")
            return text_content
        else:
            logger.warning(f"Scraping via requests/BeautifulSoup for {url} yielded minimal content (length: {len(text_content) if text_content else 0}).")
            return None
    except Exception as e:
        logger.error(f"Error parsing website content with BeautifulSoup for {url}: {e}", exc_info=True)
        return None

async def get_website_content_via_urltotext_api(url: str, api_key: str) -> Optional[str]:
    """Fetches website content using the UrlToText API."""
    if not api_key: return None
    api_endpoint = "https://api.urltotext.ai/text"
    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
    payload = {"url": url, "text_only": True} # Requesting only text content
    logger.info(f"Attempting website content fetch via UrlToText API for: {url}")

    try:
        async with httpx.AsyncClient(timeout=45.0) as client: # Increased timeout
            response = await client.post(api_endpoint, headers=headers, json=payload)
            response.raise_for_status()
            data = response.json()
            if "text" in data and data["text"]:
                content = data["text"]
                logger.info(f"Successfully fetched content via UrlToText API for {url} (length: {len(content)})")
                return content
            else:
                logger.warning(f"UrlToText API response did not contain text for {url}. Response: {data}")
                return None
    except httpx.HTTPStatusError as e:
        logger.error(f"UrlToText API HTTP error for {url}: {e.response.status_code} - {e}")
    except Exception as e:
        logger.error(f"Error fetching content via UrlToText API for {url}: {e}", exc_info=True)
    return None

# --- Summarization Function ---
async def generate_summary(content: str, summary_type: str, api_key: Optional[str]) -> str:
    """Generates a summary using OpenRouter API."""
    if not api_key:
        return "Error: OpenRouter API key is not configured."
    if not content:
        return "Error: No content provided to summarize."

    # Basic check for content length
    if len(content) < 50:
        return "The provided content is too short to summarize effectively."

    # Truncate content if too long (adjust limit as needed based on model context window)
    # This limit depends heavily on the chosen model. Claude Sonnet 3.5 has 200k tokens.
    # Let's aim for roughly 100k characters as a safe-ish limit for many models.
    max_chars = 100000
    if len(content) > max_chars:
        logger.warning(f"Content length ({len(content)}) exceeds max_chars ({max_chars}), truncating.")
        content = content[:max_chars]

    prompt_template = """
Please summarize the following text.
Provide the summary in {format_style} format.

Text to summarize:
---
{text}
---

Summary ({format_style}):
"""
    format_style = "a concise paragraph" if summary_type == "paragraph" else "bullet points (using * or - for each point)"

    prompt = prompt_template.format(text=content, format_style=format_style)

    # Recommended model: claude-3.5-sonnet-20240620, but allow others
    model_to_use = os.environ.get("OPENROUTER_MODEL", "anthropic/claude-3.5-sonnet") # Default to Claude 3.5 Sonnet

    logger.info(f"Sending request to OpenRouter (Model: {model_to_use}) for {summary_type} summary.")

    try:
        async with httpx.AsyncClient(timeout=120.0) as client: # Increased timeout for generation
            response = await client.post(
                url="https://openrouter.ai/api/v1/chat/completions",
                headers={
                    "Authorization": f"Bearer {api_key}",
                    "Content-Type": "application/json"
                },
                json={
                    "model": model_to_use,
                    "messages": [{"role": "user", "content": prompt}],
                    "max_tokens": 1024, # Adjust as needed
                },
            )
            response.raise_for_status()
            data = response.json()

            if data.get("choices") and len(data["choices"]) > 0:
                summary = data["choices"][0].get("message", {}).get("content", "").strip()
                if summary:
                    logger.info(f"Summary generated successfully (length: {len(summary)})")
                    # Simple Markdown sanitization (escape potential conflicts)
                    summary = summary.replace('_', r'\_').replace('*', r'\*').replace('[', r'\[').replace('`', r'\`')
                    return summary
                else:
                    logger.error("OpenRouter response successful, but summary content is empty.")
                    return "Sorry, the AI generated an empty summary. Please try again."
            else:
                logger.error(f"OpenRouter response format unexpected: {data}")
                return "Sorry, I received an unexpected response from the summarization service."

    except httpx.HTTPStatusError as e:
        error_body = ""
        try:
            error_body = e.response.text
        except Exception:
            pass # Ignore if reading body fails
        logger.error(f"OpenRouter API HTTP error: {e.response.status_code} - {e}. Response body: {error_body}")
        return f"Sorry, there was an error communicating with the summarization service (HTTP {e.response.status_code})."
    except Exception as e:
        logger.error(f"Error generating summary via OpenRouter: {e}", exc_info=True)
        return "Sorry, an unexpected error occurred while generating the summary."


# --- Background Task Processing ---
async def process_summary_task(
    user_id: int,
    chat_id: int,
    message_id_to_edit: Optional[int], # Can be None if original message couldn't be edited
    url: str,
    summary_type: str,
    bot_token: str
) -> None:
    """Handles the actual fetching and summarization in a background task."""
    task_id = f"{user_id}-{message_id_to_edit or 'new'}"
    logger.info(f"[Task {task_id}] Starting processing for URL: {url}")

    # Create a new bot instance for this task
    # Use longer timeouts for background tasks which might involve heavy network I/O
    custom_request = HTTPXRequest(
        connect_timeout=15.0, read_timeout=60.0, write_timeout=60.0, pool_timeout=60.0, http_version="1.1"
    )
    bot = Bot(token=bot_token, request=custom_request)

    content = None
    user_feedback_message = None
    success = False
    final_summary = ""
    status_message_id = message_id_to_edit # Start assuming we can edit the original

    try:
        # --- Inform User Processing Has Started (Edit original or send new) ---
        processing_message_text = f"⏳ Working on your '{summary_type}' summary for:\n`{url}`\n\n_(Fetching & summarizing...)_"

        if status_message_id:
            try:
                await retry_bot_operation(
                    bot.edit_message_text,
                    chat_id=chat_id,
                    message_id=status_message_id,
                    text=processing_message_text,
                    parse_mode=ParseMode.MARKDOWN,
                    reply_markup=None # Remove buttons
                )
                logger.debug(f"[Task {task_id}] Successfully edited message {status_message_id} to 'Processing'")
            except Exception as e:
                logger.warning(f"[Task {task_id}] Could not edit original message {status_message_id}: {e}. Will send a new status message.")
                status_message_id = None # Flag to send a new message

        if not status_message_id: # If editing failed or wasn't possible
             try:
                 status_message = await retry_bot_operation(
                     bot.send_message,
                     chat_id=chat_id,
                     text=processing_message_text,
                     parse_mode=ParseMode.MARKDOWN
                 )
                 status_message_id = status_message.message_id
                 logger.debug(f"[Task {task_id}] Sent new status message {status_message_id}")
             except Exception as e:
                 logger.error(f"[Task {task_id}] Failed to send new status message: {e}")
                 # Cannot proceed without informing user
                 raise RuntimeError("Failed to send initial status message") from e

        # --- Main Content Fetching and Summarization ---
        try:
            await retry_bot_operation(bot.send_chat_action, chat_id=chat_id, action='typing')

            # --- Determine Content Type and Fetch ---
            is_yt = is_youtube_url(url)
            logger.debug(f"[Task {task_id}] URL is YouTube: {is_yt}")

            if is_yt:
                video_id = extract_youtube_id(url)
                if video_id:
                    logger.info(f"[Task {task_id}] Fetching YouTube transcript for {video_id}")
                    content = await get_youtube_transcript(video_id, url, SUPADATA_API_KEY, APIFY_API_TOKEN)
                    if not content:
                        user_feedback_message = "⚠️ Sorry, I couldn't retrieve the transcript for that YouTube video. It might be disabled or unavailable."
                else:
                    user_feedback_message = "⚠️ Couldn't extract a valid YouTube video ID from the link."
            else:
                logger.info(f"[Task {task_id}] Attempting website scrape for: {url}")
                content = await get_website_content_via_requests(url)
                if not content and URLTOTEXT_API_KEY:
                    logger.info(f"[Task {task_id}] Basic scrape failed or insufficient, trying UrlToText API...")
                    await retry_bot_operation(bot.send_chat_action, chat_id=chat_id, action='typing')
                    content = await get_website_content_via_urltotext_api(url, URLTOTEXT_API_KEY)

                if not content:
                    user_feedback_message = "⚠️ Sorry, I couldn't fetch or extract meaningful content from that website."

            # --- Generate Summary if Content Was Fetched ---
            if content:
                logger.info(f"[Task {task_id}] Content fetched (length: {len(content)}). Generating '{summary_type}' summary.")
                await retry_bot_operation(bot.send_chat_action, chat_id=chat_id, action='typing')

                final_summary = await generate_summary(content, summary_type, OPENROUTER_API_KEY)

                if final_summary.startswith("Error:") or final_summary.startswith("Sorry,"):
                    user_feedback_message = f"⚠️ {final_summary}" # Use the error from generate_summary
                else:
                    success = True # Summary generated successfully

            # If content fetching failed initially, user_feedback_message is already set

        except Exception as e:
            logger.error(f"[Task {task_id}] Error during content fetching or summarization: {e}", exc_info=True)
            user_feedback_message = "❌ An unexpected error occurred while processing your request."

        # --- Send Final Result or Error ---
        if success and final_summary:
            # Split summary if it's too long for one message
            max_length = 4096
            summary_parts = [final_summary[i:i+max_length] for i in range(0, len(final_summary), max_length)]

            # Send the first part (or the only part)
            await retry_bot_operation(
                bot.send_message,
                chat_id=chat_id,
                text=summary_parts[0],
                parse_mode=ParseMode.MARKDOWN,
                link_preview_options={'is_disabled': True} # Changed to dict format for PTB v21+
            )
            # Send subsequent parts if any
            for part in summary_parts[1:]:
                 await asyncio.sleep(0.5) # Small delay between parts
                 await retry_bot_operation(
                     bot.send_message,
                     chat_id=chat_id,
                     text=part,
                     parse_mode=ParseMode.MARKDOWN,
                     link_preview_options={'is_disabled': True}
                 )
            logger.info(f"[Task {task_id}] Successfully sent summary ({len(summary_parts)} parts).")

        elif user_feedback_message: # Handle errors (either from fetching or summarization)
            logger.warning(f"[Task {task_id}] Sending feedback/error message: {user_feedback_message}")
            await retry_bot_operation(
                bot.send_message,
                chat_id=chat_id,
                text=user_feedback_message,
                link_preview_options={'is_disabled': True}
            )

        else: # Should not happen, but safety net
            logger.error(f"[Task {task_id}] Reached end of task without success or specific error message.")
            await retry_bot_operation(
                bot.send_message,
                chat_id=chat_id,
                text="❓ Something went wrong, but no specific error was identified.",
                link_preview_options={'is_disabled': True}
            )


    except Exception as e:
        logger.critical(f"[Task {task_id}] Critical error within task processing: {e}", exc_info=True)
        try:
            await retry_bot_operation(
                bot.send_message,
                chat_id=chat_id,
                text="❌ A critical internal error occurred. Please report this if it persists."
            )
        except Exception:
            logger.exception(f"[Task {task_id}] Failed even to send critical error message.")
    finally:
        # --- Clean up Status Message ---
        if status_message_id:
            try:
                await retry_bot_operation(bot.delete_message, chat_id=chat_id, message_id=status_message_id)
                logger.debug(f"[Task {task_id}] Deleted status message {status_message_id}")
            except Exception as e:
                logger.warning(f"[Task {task_id}] Failed to delete status message {status_message_id}: {e}")

        # Ensure bot session is closed
        if bot and bot.session:
             try:
                 await bot.shutdown() # Use bot.shutdown() which includes closing the session
                 logger.debug(f"[Task {task_id}] Background bot instance shut down.")
             except Exception as e:
                 logger.warning(f"[Task {task_id}] Error shutting down background bot instance: {e}")

        logger.info(f"[Task {task_id}] Task completed. Success: {success}")


# --- Telegram Bot Handlers ---
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    """Handles the /start command."""
    user = update.effective_user
    if not user or not update.message: return
    logger.info(f"User {user.id} initiated /start.")
    mention = user.mention_html() # mention_html is safer
    start_message = (
        f"👋 Hello {mention}!\n\n"
        "I can summarise YouTube videos or web articles for you.\n\n"
        "Just send me a link (URL) and I'll ask you whether you want the summary as a paragraph or bullet points.\n\n"
        "Type /help for more details."
    )
    await update.message.reply_html(start_message)

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    """Handles the /help command."""
    user = update.effective_user
    if not user or not update.message: return
    logger.info(f"User {user.id} requested /help.")
    help_text = (
        "**How to Use Me:**\n"
        "1. Send me a direct link (URL) to a YouTube video or a web article.\n"
        "2. I will ask you to choose the summary format: `Paragraph` or `Points`.\n"
        "3. Click the button for your preferred format.\n"
        "4. I'll fetch the content, summarise it using AI, and send it back to you!\n\n"
        "**Important Notes:**\n"
        "- **YouTube:** Getting transcripts can sometimes fail if they are disabled or unavailable.\n"
        "- **Websites:** I try my best, but complex or JavaScript-heavy sites might not work perfectly.\n"
        "- **AI Summaries:** The AI aims for accuracy but may occasionally miss nuances or make errors.\n"
        "- **Length Limits:** Very long videos or articles might be truncated before summarization.\n\n"
        "Just send a link to get started!"
    )
    # Use reply_markdown_v2 for safer Markdown parsing if needed, but MARKDOWN should suffice here
    await update.message.reply_text(help_text, parse_mode=ParseMode.MARKDOWN)

async def handle_potential_url(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    """Handles messages containing potential URLs."""
    if not update.message or not update.message.text: return
    message_text = update.message.text.strip()
    user = update.effective_user
    if not user: return

    # Improved URL regex (simplified for matching, not validation)
    url_pattern = r'https?://[^\s<>"]+|www\.[^\s<>"]+'
    match = re.search(url_pattern, message_text)

    if match:
        url = match.group(0)
        # Basic cleanup: remove trailing characters like periods or commas if they likely aren't part of URL
        url = re.sub(r'[.,!?)\]>]+$', '', url)
        logger.info(f"User {user.id} sent potential URL: {url}")

        # Store URL and the original message ID for potential editing
        context.user_data['url_to_summarize'] = url
        context.user_data['original_message_id'] = update.message.message_id # Store for potential edit

        keyboard = [
            [
                InlineKeyboardButton("📜 Paragraph", callback_data="paragraph"), # Shortened labels
                InlineKeyboardButton("🔹 Bullet Points", callback_data="points")
            ]
        ]
        reply_markup = InlineKeyboardMarkup(keyboard)
        await update.message.reply_text(
            f"✅ Link received:\n`{url}`\n\nChoose your desired summary format:",
            reply_markup=reply_markup,
            parse_mode=ParseMode.MARKDOWN,
            link_preview_options={'is_disabled': True}
        )
    elif not message_text.startswith('/'):
        # Avoid replying to non-URL, non-command text to prevent noise
        logger.debug(f"User {user.id} sent non-URL, non-command text: '{message_text[:50]}...'")
        # Optional: Send a hint if it looks like they *tried* to send a URL
        if "http" in message_text or "www." in message_text:
             await update.message.reply_text("Hmm, that looks like it might be a link, but please ensure it starts with `http://` or `https://` and is a valid URL.")
        # else: do nothing

async def handle_summary_type_callback(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    """Handles button presses for summary type selection."""
    query = update.callback_query
    if not query or not query.message or not query.from_user:
        logger.warning("Callback query received without essential data.")
        if query: await query.answer() # Try to answer anyway
        return

    user = query.from_user
    summary_type = query.data
    query_id = query.id

    # --- Acknowledge button press ---
    # This is where the original error occurred. Trying this early.
    try:
        await query.answer()
        logger.debug(f"Acknowledged callback query {query_id} from user {user.id}")
    except Exception as e:
        # Log the error but try to continue, as acknowledging isn't strictly critical
        logger.error(f"Error answering callback query {query_id} from user {user.id}: {e}", exc_info=True)
        # The original NetworkError might still happen here in problematic environments.
        # If it persists, it points to deeper issues with httpx/anyio/uvloop/PTB interaction.

    # --- Retrieve URL and Original Message ID ---
    url = context.user_data.get('url_to_summarize')
    # Use the message ID from the callback query's message - this IS the message with buttons
    message_id_to_edit = query.message.message_id

    logger.info(f"User {user.id} chose summary type '{summary_type}' for URL associated with message {message_id_to_edit}")

    if not url:
        logger.warning(f"No URL found in user_data for user {user.id} (callback query {query_id}). Editing message.")
        try:
            await query.edit_message_text(text="⚠️ Oops! I couldn't find the link associated with this request. Please send the link again.")
        except Exception as e:
            logger.error(f"Failed to edit message to show 'URL not found' error: {e}")
        return

    # --- Clear user_data and schedule task ---
    context.user_data.pop('url_to_summarize', None)
    context.user_data.pop('original_message_id', None) # Clear stored ID

    if not TELEGRAM_TOKEN:
         logger.critical("TELEGRAM_TOKEN is missing, cannot start background task!")
         try:
             await query.edit_message_text(text="❌ Internal configuration error. Cannot process request.")
         except Exception: pass
         return

    logger.info(f"Scheduling background task for user {user.id}, chat {query.message.chat_id}, message {message_id_to_edit}, type {summary_type}")
    asyncio.create_task(
        process_summary_task(
            user_id=user.id,
            chat_id=query.message.chat_id,
            message_id_to_edit=message_id_to_edit, # Pass the ID of the message with buttons
            url=url,
            summary_type=summary_type,
            bot_token=TELEGRAM_TOKEN # Pass token
        ),
        name=f"SummaryTask-{user.id}-{message_id_to_edit}"
    )


async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE) -> None:
    """Log Errors caused by Updates or background tasks."""
    logger.error("Exception while handling an update:", exc_info=context.error)

    # Optionally, inform the user about backend errors if appropriate
    # Be careful not to spam users if the error is persistent
    # if isinstance(context.error, (NetworkError, TimedOut)):
    #     # Potentially inform user about temporary issues
    #     pass
    # elif isinstance(context.error, TelegramError):
    #     # Handle specific Telegram API errors if needed
    #      pass


# --- Bot Setup Function ---
async def setup_bot_config() -> Application:
    """Configures the PTB Application."""
    logger.info("Configuring Telegram Application...")
    if not TELEGRAM_TOKEN:
        raise ValueError("TELEGRAM_TOKEN environment variable not set.")

    # Configure httpx client for PTB (timeouts are important)
    custom_request = HTTPXRequest(
        connect_timeout=10.0,
        read_timeout=30.0, # Read timeout for API calls like getMe, getUpdates etc.
        write_timeout=30.0,
        pool_timeout=60.0, # Allow keeping connections open longer
        http_version="1.1" # Stick to 1.1 for wider compatibility
    )

    application = (
        Application.builder()
        .token(TELEGRAM_TOKEN)
        .request(custom_request)
        # Consider connection_pool_size if expecting high concurrency
        # .connection_pool_size(10)
        .build()
    )

    # Add handlers
    application.add_handler(CommandHandler("start", start))
    application.add_handler(CommandHandler("help", help_command))
    # Use TEXT filter combined with URL entity/filter for better targeting?
    # For simplicity, keeping the regex check inside the handler for now.
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_potential_url))
    application.add_handler(CallbackQueryHandler(handle_summary_type_callback))

    # Add error handler
    application.add_error_handler(error_handler)

    logger.info("Telegram application handlers configured.")
    return application

# --- ASGI Lifespan Context Manager (Mostly Unchanged) ---
@contextlib.asynccontextmanager
async def lifespan(app: Starlette):
    """Handles PTB startup and shutdown during ASGI lifespan."""
    global ptb_app
    logger.info("ASGI Lifespan: Startup sequence initiated...")

    if not TELEGRAM_TOKEN:
        logger.critical("TELEGRAM_TOKEN is not set. Bot cannot start.")
        raise RuntimeError("Telegram token missing.")

    bot_info_text = "Bot info not available yet."
    try:
        ptb_app = await setup_bot_config()
        await ptb_app.initialize() # Initialize application resources

        bot_info = await ptb_app.bot.get_me()
        bot_info_text = f"@{bot_info.username} (ID: {bot_info.id})"
        logger.info(f"Bot initialized: {bot_info_text}")

        # Check for existing webhook and potentially delete it before setting a new one
        current_webhook_info = await ptb_app.bot.get_webhook_info()
        if current_webhook_info and current_webhook_info.url:
            logger.info(f"Found existing webhook: {current_webhook_info.url}. Attempting to delete it.")
            try:
                await ptb_app.bot.delete_webhook(drop_pending_updates=True)
                logger.info("Existing webhook deleted successfully.")
            except Exception as e:
                logger.warning(f"Could not delete existing webhook: {e}")
                await asyncio.sleep(1) # Short pause before setting new one


        # Determine Webhook URL from Hugging Face environment variables
        space_host = os.environ.get("SPACE_HOST")
        webhook_path = "/webhook" # Keep it simple
        full_webhook_url = None

        if space_host:
            # Ensure it starts with https://
            if not space_host.startswith("https://"):
                 # HF usually provides full host like 'user-repo.hf.space'
                 # Prepend https:// if missing
                 if not space_host.startswith("http"):
                      full_webhook_url = f"https://{space_host.rstrip('/')}{webhook_path}"
                 else: # If it starts with http://, replace it (HF uses https)
                      full_webhook_url = f"https://{space_host.split('://')[1].rstrip('/')}{webhook_path}"

            if full_webhook_url:
                logger.info(f"Attempting to set webhook to: {full_webhook_url}")
                await asyncio.sleep(2.0) # Give network time to settle
                try:
                    await ptb_app.bot.set_webhook(
                        url=full_webhook_url,
                        allowed_updates=Update.ALL_TYPES, # Or specify types like ['message', 'callback_query']
                        drop_pending_updates=True,
                        secret_token=os.environ.get("WEBHOOK_SECRET") # Optional: Add a secret token for security
                    )
                    webhook_info = await ptb_app.bot.get_webhook_info()
                    logger.info(f"Webhook successfully set: URL='{webhook_info.url}', Pending={webhook_info.pending_update_count}")
                    # Start PTB's internal runners *after* setting the webhook
                    await ptb_app.start()
                    logger.info("PTB Application started (webhook mode). Ready for updates.")
                except Exception as e:
                    logger.error(f"FATAL: Failed to set webhook to {full_webhook_url}: {e}", exc_info=True)
                    # Decide how to handle failure: maybe try polling or just exit?
                    # For HF Spaces webhook is preferred. Raising error might be best.
                    raise RuntimeError(f"Failed to set webhook: {e}") from e
            else:
                 logger.warning("Could not construct valid HTTPS webhook URL from SPACE_HOST.")
                 # Fallback or error needed here? For HF, webhook is essential.
                 raise RuntimeError("Webhook URL could not be determined.")
        else:
            logger.warning("SPACE_HOST environment variable not found. Cannot set webhook.")
            # Maybe fall back to polling for local dev? Not ideal for HF.
            # logger.info("Starting PTB in polling mode (no SPACE_HOST found).")
            # await ptb_app.start() # Start runners
            # application.run_polling(drop_pending_updates=True) # Start polling - BLOCKING! Not suitable for ASGI app.
            raise RuntimeError("SPACE_HOST env var missing, cannot run in webhook mode.")


        logger.info("ASGI Lifespan: Startup complete.")
        yield # Application runs here

    except Exception as startup_err:
        logger.critical(f"Application startup failed: {startup_err}", exc_info=True)
        # Ensure cleanup happens even if startup fails partially
        if ptb_app and ptb_app.running:
             await ptb_app.stop()
        if ptb_app:
             await ptb_app.shutdown()
        raise # Reraise the error to stop the ASGI server
    finally:
        logger.info("ASGI Lifespan: Shutdown sequence initiated...")
        if ptb_app:
            if ptb_app.running:
                 logger.info("Stopping PTB application...")
                 await ptb_app.stop()
            logger.info("Shutting down PTB application...")
            await ptb_app.shutdown()
            logger.info("PTB Application shut down gracefully.")
        else:
            logger.info("PTB application was not initialized or startup failed.")
        logger.info("ASGI Lifespan: Shutdown complete.")


# --- Starlette Route Handlers ---
async def health_check(request: Request) -> PlainTextResponse:
    """Basic health check endpoint."""
    bot_status = "Not Initialized"
    if ptb_app and ptb_app.bot:
        try:
             # Perform a lightweight check like get_me again, or use a flag
             if ptb_app.running:
                 bot_info = await ptb_app.bot.get_me() # Cached usually
                 bot_status = f"Running (@{bot_info.username})"
             else:
                 bot_status = "Initialized but not running"
        except Exception as e:
             bot_status = f"Error checking status: {e}"

    return PlainTextResponse(f"Telegram Bot Summarizer - Status: {bot_status}")

async def telegram_webhook(request: Request) -> Response:
    """Webhook endpoint called by Telegram."""
    if not ptb_app:
        logger.error("Webhook received but PTB application not initialized.")
        return PlainTextResponse('Bot not initialized', status_code=503)
    if not ptb_app.running:
         logger.warning("Webhook received but PTB application not running.")
         # Maybe return 200 OK anyway so Telegram doesn't retry too much?
         # Or 503 Service Unavailable
         return PlainTextResponse('Bot initialized but not running', status_code=503)

    try:
        # Check secret token if configured
        secret_token = os.environ.get("WEBHOOK_SECRET")
        if secret_token:
             if request.headers.get("X-Telegram-Bot-Api-Secret-Token") != secret_token:
                  logger.warning("Webhook received with invalid secret token.")
                  return Response(status_code=403) # Forbidden

        # Process the update
        update_data = await request.json()
        update = Update.de_json(data=update_data, bot=ptb_app.bot)
        logger.debug(f"Processing update_id: {update.update_id}")
        await ptb_app.process_update(update)
        return Response(status_code=200) # OK

    except json.JSONDecodeError:
        logger.error("Webhook received invalid JSON.")
        return PlainTextResponse('Bad Request: Invalid JSON', status_code=400)
    except Exception as e:
        logger.error(f"Error processing webhook update: {e}", exc_info=True)
        # Return 200 OK even on errors to prevent Telegram retries if the error is in processing logic
        # Alternatively return 500 if it's a server-side issue. 200 is often safer for webhooks.
        return Response(status_code=200) # OK despite error

# --- Create Starlette ASGI Application ---
app = Starlette(
    debug=False, # Set debug based on environment if needed
    lifespan=lifespan,
    routes=[
        Route("/", endpoint=health_check, methods=["GET"]),
        Route("/webhook", endpoint=telegram_webhook, methods=["POST"]),
    ]
)
logger.info("Starlette ASGI application created with native routes.")

# --- Development Server Execution Block (Optional) ---
# This block is generally NOT used when deploying with Gunicorn/Uvicorn
# Keep it for potential local testing without gunicorn
if __name__ == '__main__':
    import uvicorn
    logger.warning("Running in development mode using Uvicorn directly (not for production)")
    local_port = int(os.environ.get('PORT', 8080)) # Use PORT if set, else 8080
    uvicorn.run(app, host='0.0.0.0', port=local_port, log_level="info")