Args:
    url: The URL to follow (e.g., Sign-Up Genius link)
    context_summary: Brief context about what the signup is for
    dry_run: If True, don't actually fetch or extract

Returns:
    Dict with status, slots, and formatted message for Telegram.
"""
if dry_run:
    return {
        "status": "DRY_RUN",
        "url": url,
        "slots": [],
        "message": f"🔍 Would fetch and extract slots from: {url[:60]}",
    }

# Step 1: Fetch the URL via Jina Reader
markdown = fetch_url_as_markdown(url)
if not markdown:
    return {
        "status": "FETCH_FAILED",
        "url": url,
        "slots": [],
        "message": f"❌ Couldn't load signup page: {url[:60]}",
    }

# Step 2: Extract slots via LLM
slots = _extract_slots(markdown, context_summary)

if not slots:
    return {
        "status": "NO_SLOTS",
        "url": url,
        "slots": [],
        "message": f"ℹ️ No signup slots found at: {url[:60]}",
    }

# Step 3: Format for Telegram
message = _format_slots_message(slots, context_summary, url)

return {
    "status": "SLOTS_FOUND",
    "url": url,
    "slots": slots,
    "message": message,
}

Returns a list of slot dicts, or empty list if none found.
"""
from datetime import datetime

today = datetime.now(CHICAGO_TZ).strftime("%A, %B %d, %Y")

prompt = SLOT_EXTRACT_PROMPT.replace("{today}", today)

# Truncate markdown if too long (keep first 8000 chars — enough for most signup forms)
if len(markdown) > 8000:
    markdown = markdown[:8000] + "\n\n[Content truncated]"

user_message = f"Context: {context_summary}\n\nPage content:\n{markdown}" if context_summary else f"Page content:\n{markdown}"

payload = {
    "model": LLM_MODEL,
    "messages": [
        {"role": "system", "content": prompt},
        {"role": "user", "content": user_message},
    ],
    "temperature": 0.1,
    "stream": False,
}

try:
    resp = requests.post(LLM_URL, json=payload, timeout=LLM_TIMEOUT)
    resp.raise_for_status()
    data = resp.json()

    # Handle both OpenAI and Ollama response formats
    choices = data.get("choices", [])
    if choices:
        raw = choices[0].get("message", {}).get("content", "").strip()
    elif "message" in data:
        raw = data["message"].get("content", "").strip()
    else:
        raw = data.get("response", "").strip()

    # Strip markdown code fences
    raw = re.sub(r"^```(?:json)?\s*", "", raw)
    raw = re.sub(r"\s*```$", "", raw)

    try:
        slots = json.loads(raw)
    except json.JSONDecodeError:
        # Try to extract JSON array
        match = re.search(r"\[.*\]", raw, re.DOTALL)
        if match:
            slots = json.loads(match.group())
        else:
            print("  [Clicker] Could not parse LLM response as JSON", file=sys.stderr)
            return []

    if not isinstance(slots, list):
        return []

    return slots

except requests.exceptions.Timeout:
    print("  [Clicker] LLM timeout during slot extraction", file=sys.stderr)
    return []
except Exception as e:
    print(f"  [Clicker] Error extracting slots: {e}", file=sys.stderr)
    return []

Groups slots by category, then by date, then lists times.
"""
from datetime import datetime

# Group by category
categories = {}
for slot in slots:
    cat = slot.get("category", "General")
    if cat not in categories:
        categories[cat] = []
    categories[cat].append(slot)

lines = []
if context_summary:
    lines.append(f"📋 **{context_summary}**\n")

for cat, cat_slots in categories.items():
    if len(categories) > 1:
        lines.append(f"**{cat}**")

    # Group by date within category
    by_date = {}
    for slot in cat_slots:
        time_str = slot.get("time", "")
        date_str = slot.get("date", "")
        if time_str:
            try:
                dt = datetime.fromisoformat(time_str)
                date_key = dt.strftime("%a %b %d")
                time_label = dt.strftime("%-I:%M %p")
            except (ValueError, TypeError):
                date_key = "Unknown date"
                time_label = time_str
        elif date_str:
            try:
                dt = datetime.fromisoformat(date_str)
                date_key = dt.strftime("%a %b %d")
                time_label = None
            except (ValueError, TypeError):
                date_key = "Unknown date"
                time_label = None
        else:
            date_key = "Unknown date"
            time_label = None

        if date_key not in by_date:
            by_date[date_key] = []
        by_date[date_key].append({
            "time_label": time_label,
            "label": slot.get("label", ""),
            "spots": slot.get("spots_remaining"),
        })

    for date, date_slots in by_date.items():
        lines.append(f"  📅 {date}")
        for s in date_slots:
            entry = f"    • {s['time_label']}" if s["time_label"] else f"    • {s['label']}"
            if s["spots"] is not None:
                entry += f" ({s['spots']} spots)"
            lines.append(entry)

    lines.append("")

lines.append(f"🔗 [Open signup page]({url})")

return "\n".join(lines)

Each button has callback_data: slot|<url_hash>|<slot_index>
Max 1 row per slot (Telegram limit), max ~10 buttons.

Args:
    slots: List of slot dicts from _extract_slots()
    url_hash: Short hash of the URL for callback identification

Returns:
    List of button rows for Telegram inline keyboard.
"""
if not url_hash:
    url_hash = "0"

rows = []
for i, slot in enumerate(slots[:10]):  # Max 10 buttons
    time_str = slot.get("time", "")
    label = slot.get("label", "")

    # Format button text — prefer time over label
    if time_str:
        try:
            from datetime import datetime
            dt = datetime.fromisoformat(time_str)
            button_text = dt.strftime("%a %-I:%M %p")  # e.g. "Sat 8:00 AM"
        except (ValueError, TypeError):
            button_text = time_str[:20]
    elif label:
        # Use label but allow longer text for single-slot scenarios
        button_text = label[:30] if len(slots) > 1 else label[:40]
    else:
        button_text = f"Slot {i+1}"

    # Add spots remaining
    spots = slot.get("spots_remaining")
    if spots is not None:
        button_text += f" ({spots})"

    callback = f"slot|{url_hash}|{i}"
    rows.append([{"text": button_text, "callback_data": callback}])

return rows