Recevoir ses notifications GitHub sur Telegram gratuitement avec AWS Lambda

{
  "ok": true,
  "result": [{
    "message": {
      "chat": {
        "id": 123456789,
        "type": "private"
      },
      "text": "/start"
    }
  }]
}

# Token du bot Telegram
aws ssm put-parameter \
  --name "/github-notifier/telegram-bot-token" \
  --value "<TON_TOKEN_TELEGRAM>" \
  --type SecureString \
  --overwrite

# Chat ID Telegram
aws ssm put-parameter \
  --name "/github-notifier/telegram-chat-id" \
  --value "<TON_CHAT_ID>" \
  --type SecureString \
  --overwrite

# Token GitHub
aws ssm put-parameter \
  --name "/github-notifier/github-token" \
  --value "<TON_TOKEN_GITHUB>" \
  --type SecureString \
  --overwrite

aws ssm get-parameter \
  --name "/github-notifier/telegram-bot-token" \
  --with-decryption \
  --query "Parameter.Value" \
  --output text

# src/lambda_function.py
import json
import logging
import config
import monitoring
from github_poller import fetch_notifications, mark_all_read
from formatters import format_notification
from telegram_sender import send_notification, send_message
from telegram_commands import handle_command, parse_update
from dedup import group_notifications

logger = logging.getLogger()
logger.setLevel(logging.INFO)


def lambda_handler(event, context):
    try:
        result = _handle(event, context)
        monitoring.reset_crash_counter()
        return result
    except Exception as e:
        logger.exception("Unhandled exception")
        count = monitoring.increment_crash_counter()
        if count >= 3:
            monitoring.alert_crash(count)
        return {"statusCode": 500, "body": str(e)}


def _handle(event, context):
    # Déterminer la source de l'événement
    is_scheduler = (
        event.get("source") == "aws.scheduler"
        or "detail-type" in event
        or not event.get("requestContext")
    )

    if is_scheduler:
        return _handle_scheduler()
    else:
        return _handle_http(event)


def _handle_scheduler():
    """Déclenché par EventBridge : poll GitHub et envoie les notifications."""
    paused = config.get_state("paused", "false")
    if paused.lower() == "true":
        logger.info("Bot is paused, skipping poll")
        return {"statusCode": 200, "body": "paused"}

    github_token = config.get_github_token()
    telegram_token = config.get_telegram_token()
    chat_id = config.get_telegram_chat_id()

    notifications = fetch_notifications(github_token)
    logger.info(f"Fetched {len(notifications)} notifications")

    if not notifications:
        return {"statusCode": 200, "body": "no new notifications"}

    # Dédupliquer par subject_url
    groups = group_notifications(notifications)

    for notifs in groups:
        text = format_notification(notifs[0]) if len(notifs) == 1 else _format_grouped(notifs)
        send_notification(notifs[0], text, telegram_token, chat_id)

    mark_all_read(github_token)

    return {"statusCode": 200, "body": f"sent {len(groups)} messages"}


def _handle_http(event):
    """Déclenché par une requête HTTP : commande Telegram ou callback."""
    body_raw = event.get("body", "{}")
    try:
        body = json.loads(body_raw) if isinstance(body_raw, str) else body_raw
    except json.JSONDecodeError:
        return {"statusCode": 400, "body": "invalid json"}

    telegram_token = config.get_telegram_token()
    chat_id = config.get_telegram_chat_id()

    update = parse_update(body)
    if not update:
        return {"statusCode": 200, "body": "ignored"}

    handle_command(update, telegram_token, chat_id)
    return {"statusCode": 200, "body": "ok"}


def _format_grouped(notifs):
    """Format condensé pour plusieurs notifications sur le même sujet."""
    from dedup import format_grouped
    return format_grouped(notifs)

# src/config.py
import boto3
import json
import os
import logging

logger = logging.getLogger(__name__)

_ssm = boto3.client("ssm")
SSM_PREFIX = os.environ.get("SSM_PREFIX", "/github-notifier")

# Cache cold start : chargé une fois par instance Lambda
_secrets_cache: dict = {}


def _get_secret(name: str) -> str | None:
    """Lit un SecureString depuis SSM avec cache au cold start."""
    key = f"{SSM_PREFIX}/{name}"
    if key in _secrets_cache:
        return _secrets_cache[key]
    try:
        resp = _ssm.get_parameter(Name=key, WithDecryption=True)
        value = resp["Parameter"]["Value"]
        _secrets_cache[key] = value
        return value
    except _ssm.exceptions.ParameterNotFound:
        logger.warning(f"SSM parameter not found: {key}")
        return None
    except Exception as e:
        logger.error(f"Error reading SSM parameter {key}: {e}")
        raise


def get_telegram_token() -> str:
    return _get_secret("telegram-bot-token")


def get_telegram_chat_id() -> str:
    return _get_secret("telegram-chat-id")


def get_github_token() -> str:
    return _get_secret("github-token")


def get_state(key: str, default: str = "") -> str:
    """Lit un paramètre d'état (String, pas de cache)."""
    full_name = f"{SSM_PREFIX}/state/{key}"
    try:
        resp = _ssm.get_parameter(Name=full_name, WithDecryption=False)
        return resp["Parameter"]["Value"]
    except _ssm.exceptions.ParameterNotFound:
        return default
    except Exception as e:
        logger.error(f"Error reading state {key}: {e}")
        return default


def set_state(key: str, value: str) -> None:
    """Écrit un paramètre d'état dans SSM."""
    full_name = f"{SSM_PREFIX}/state/{key}"
    try:
        _ssm.put_parameter(
            Name=full_name,
            Value=str(value),
            Type="String",
            Overwrite=True,
        )
    except Exception as e:
        logger.error(f"Error writing state {key}: {e}")
        raise


def get_muted_repos() -> list:
    """Retourne la liste des repos mutés (stockée en JSON dans SSM)."""
    raw = get_state("muted-repos", "[]")
    try:
        return json.loads(raw)
    except (json.JSONDecodeError, TypeError):
        return []


def set_muted_repos(repos: list) -> None:
    """Sauvegarde la liste des repos mutés."""
    set_state("muted-repos", json.dumps(repos))

# src/models.py
from dataclasses import dataclass, field
from typing import Optional


@dataclass
class GitHubNotification:
    id: str
    type: str           # PullRequest, Issue, Release, CheckSuite, Discussion…
    reason: str         # review_requested, assign, mention, author, comment…
    subject_title: str
    subject_url: str    # URL API du sujet (ex: api.github.com/repos/.../pulls/42)
    subject_type: str   # PullRequest, Issue, Commit, Release…
    repo_full_name: str # owner/repo
    updated_at: str
    details: Optional[dict] = field(default=None)  # Détails fetchés depuis subject_url


@dataclass
class TelegramMessage:
    text: str
    parse_mode: str = "HTML"
    reply_to_message_id: Optional[int] = None
    inline_keyboard: Optional[list] = field(default=None)

# src/github_poller.py
import urllib.request
import urllib.error
import json
import logging
from datetime import datetime, timezone

import config
import monitoring
from models import GitHubNotification

logger = logging.getLogger(__name__)
GITHUB_API = "https://api.github.com"


def _make_request(
    url: str,
    token: str,
    last_modified: str = None,
    method: str = "GET",
    body: bytes = None,
) -> tuple[int, dict, any]:
    """Effectue une requête vers l'API GitHub."""
    req = urllib.request.Request(url, method=method, data=body)
    req.add_header("Authorization", f"token {token}")
    req.add_header("Accept", "application/vnd.github.v3+json")
    req.add_header("X-GitHub-Api-Version", "2022-11-28")
    if last_modified:
        req.add_header("If-Modified-Since", last_modified)
    if body:
        req.add_header("Content-Type", "application/json")

    try:
        with urllib.request.urlopen(req) as response:
            headers = dict(response.headers)
            raw = response.read()
            data = json.loads(raw) if raw else {}
            return response.status, headers, data
    except urllib.error.HTTPError as e:
        if e.code == 304:
            return 304, {}, []
        raise


def fetch_notifications(token: str) -> list[GitHubNotification]:
    """
    Récupère les notifications non lues depuis l'API GitHub.
    Utilise If-Modified-Since pour économiser le rate limit.
    """
    last_modified = config.get_state("last-modified", "")

    status, headers, data = _make_request(
        f"{GITHUB_API}/notifications?all=false&participating=false",
        token,
        last_modified=last_modified,
    )

    # Mise à jour des métriques de rate limit
    remaining = headers.get("X-Ratelimit-Remaining") or headers.get("x-ratelimit-remaining")
    if remaining is not None:
        config.set_state("rate-limit-remaining", remaining)
        monitoring.check_rate_limit(int(remaining), token, config.get_telegram_chat_id())

    reset_ts = headers.get("X-Ratelimit-Reset") or headers.get("x-ratelimit-reset")
    if reset_ts:
        config.set_state("rate-limit-reset", reset_ts)

    # Mise à jour du Last-Modified pour la prochaine requête
    lm = headers.get("Last-Modified") or headers.get("last-modified")
    if lm:
        config.set_state("last-modified", lm)

    config.set_state("last-poll-timestamp", datetime.now(timezone.utc).isoformat())

    if status == 304:
        logger.info("304 Not Modified — aucune nouvelle notification")
        return []

    muted = config.get_muted_repos()
    notifications = []

    for item in data:
        repo_full_name = item["repository"]["full_name"]
        if repo_full_name in muted:
            logger.debug(f"Skipping muted repo: {repo_full_name}")
            continue

        notif = GitHubNotification(
            id=item["id"],
            type=item["type"],
            reason=item["reason"],
            subject_title=item["subject"]["title"],
            subject_url=item["subject"].get("url") or "",
            subject_type=item["subject"]["type"],
            repo_full_name=repo_full_name,
            updated_at=item["updated_at"],
        )

        # Fetch des détails si l'URL est disponible
        if notif.subject_url:
            try:
                _, _, details = _make_request(notif.subject_url, token)
                notif.details = details
            except Exception as e:
                logger.warning(f"Impossible de fetcher les détails pour {notif.subject_url}: {e}")

        notifications.append(notif)

    logger.info(f"{len(notifications)} notification(s) après filtrage des repos mutés")
    return notifications


def mark_all_read(token: str) -> None:
    """Marque toutes les notifications comme lues."""
    try:
        _make_request(
            f"{GITHUB_API}/notifications",
            token,
            method="PUT",
            body=json.dumps({"read": True}).encode(),
        )
        logger.info("Notifications marquées comme lues")
    except Exception as e:
        logger.error(f"Erreur lors du mark as read: {e}")

# src/formatters.py
import html as _html
from models import GitHubNotification

# Mapping reason → label affiché
REASON_LABELS = {
    "review_requested": "🔍 Review requested",
    "assign": "📌 Assigned to you",
    "mention": "💬 Mentioned",
    "author": "✍️ You're the author",
    "comment": "💬 Comment",
    "ci_activity": "🔧 CI activity",
    "state_change": "🔄 State changed",
    "security_alert": "🔒 Security alert",
    "team_mention": "👥 Team mentioned",
    "subscribed": "👁️ Subscribed",
}


def _e(text) -> str:
    """Échappe le HTML pour Telegram."""
    if text is None:
        return ""
    return _html.escape(str(text))


def _trunc(text, max_len: int = 150) -> str:
    """Tronque un texte à max_len caractères."""
    if not text:
        return ""
    text = str(text).replace("\n", " ").strip()
    return text[:max_len] + "…" if len(text) > max_len else text


def _reason(reason: str) -> str:
    return REASON_LABELS.get(reason, f"🔔 {reason}")


def _link(text: str, url: str) -> str:
    return f'<a href="{_e(url)}">{_e(text)}</a>'


def _api_to_html_url(url: str) -> str:
    """Convertit une URL API GitHub en URL HTML."""
    return (
        url.replace("api.github.com/repos/", "github.com/")
        .replace("/pulls/", "/pull/")
        .replace("/commits/", "/commit/")
    )


def format_notification(notif: GitHubNotification) -> str:
    """Dispatch vers le formatteur approprié selon le type de sujet."""
    d = notif.details or {}

    if notif.subject_type == "PullRequest":
        return _format_pr(notif, d)
    elif notif.subject_type == "Issue":
        return _format_issue(notif, d)
    elif notif.subject_type in ("Commit", "Discussion") and notif.reason == "comment":
        return _format_comment(notif, d)
    elif notif.subject_type == "Release":
        return _format_release(notif, d)
    elif notif.subject_type == "CheckSuite" or notif.reason == "ci_activity":
        return _format_ci(notif, d)
    elif notif.reason == "security_alert":
        return _format_security(notif, d)
    elif notif.subject_type == "Discussion":
        return _format_discussion(notif, d)
    else:
        return _format_fallback(notif)


def _format_pr(notif: GitHubNotification, d: dict) -> str:
    """PR opened / merged / closed."""
    state = d.get("state", "open")
    merged = d.get("merged", False)

    if merged:
        emoji, label = "🟣", "PR merged"
        merged_by = (d.get("merged_by") or {}).get("login", "?")
        action = f"Merged by: <b>{_e(merged_by)}</b>"
    elif state == "closed":
        emoji, label = "🔴", "PR closed"
        action = "Closed without merge"
    else:
        emoji, label = "🟢", "PR opened"
        author = (d.get("user") or {}).get("login", "?")
        action = f"By: <b>{_e(author)}</b>"

    head = (d.get("head") or {}).get("ref", "?")
    base = (d.get("base") or {}).get("ref", "?")
    additions = d.get("additions", 0)
    deletions = d.get("deletions", 0)
    labels = [l.get("name", "") for l in (d.get("labels") or [])]
    labels_str = " ".join(f"<code>{_e(l)}</code>" for l in labels)
    url = d.get("html_url") or _api_to_html_url(notif.subject_url)
    number = d.get("number", "")

    lines = [
        f"{emoji} <b>{label}</b> — {_link(notif.repo_full_name, url)}",
        f"<b>{_e(notif.subject_title)}</b> #{number}",
        action,
        f"Branch: <code>{_e(head)}</code> → <code>{_e(base)}</code>",
        f"Changes: <code>+{additions} / -{deletions}</code>",
    ]
    if labels_str:
        lines.append(f"Labels: {labels_str}")
    lines.append(f"<i>{_reason(notif.reason)}</i>")
    return "\n".join(lines)


def _format_issue(notif: GitHubNotification, d: dict) -> str:
    """Issue ouverte ou fermée."""
    state = d.get("state", "open")
    emoji = "🔴" if state == "closed" else "🟡"
    author = (d.get("user") or {}).get("login", "?")
    labels = [l.get("name", "") for l in (d.get("labels") or [])]
    labels_str = " ".join(f"<code>{_e(l)}</code>" for l in labels)
    assignees = [(a.get("login", "")) for a in (d.get("assignees") or [])]
    assignees_str = ", ".join(f"<b>{_e(a)}</b>" for a in assignees)
    milestone = d.get("milestone") or {}
    milestone_title = milestone.get("title", "") if isinstance(milestone, dict) else ""
    url = d.get("html_url") or _api_to_html_url(notif.subject_url)
    number = d.get("number", "")

    lines = [
        f"{emoji} <b>Issue</b> — {_link(notif.repo_full_name, url)}",
        f"<b>{_e(notif.subject_title)}</b> #{number}",
        f"By: <b>{_e(author)}</b>",
    ]
    if labels_str:
        lines.append(f"Labels: {labels_str}")
    if assignees_str:
        lines.append(f"Assignees: {assignees_str}")
    if milestone_title:
        lines.append(f"Milestone: <i>{_e(milestone_title)}</i>")
    lines.append(f"<i>{_reason(notif.reason)}</i>")
    return "\n".join(lines)


def _format_comment(notif: GitHubNotification, d: dict) -> str:
    """Commentaire sur une issue, PR ou commit."""
    author = (d.get("user") or {}).get("login", "?")
    body = _trunc(d.get("body", ""))
    url = d.get("html_url") or _api_to_html_url(notif.subject_url)

    lines = [
        f"💬 <b>Comment</b> — {_link(notif.repo_full_name, url)}",
        f"<b>{_e(notif.subject_title)}</b>",
        f"From: <b>{_e(author)}</b>",
        f"<i>{_e(body)}</i>",
        f"<i>{_reason(notif.reason)}</i>",
    ]
    return "\n".join(lines)


def _format_release(notif: GitHubNotification, d: dict) -> str:
    """Nouvelle release publiée."""
    author = (d.get("author") or {}).get("login", "?")
    tag = d.get("tag_name", "")
    assets = d.get("assets") or []
    body = _trunc(d.get("body", ""), 200)
    url = d.get("html_url") or _api_to_html_url(notif.subject_url)

    lines = [
        f"🚀 <b>Release</b> — {_link(notif.repo_full_name, url)}",
        f"<b>{_e(notif.subject_title)}</b>",
        f"By: <b>{_e(author)}</b>",
        f"Tag: <code>{_e(tag)}</code>",
        f"Assets: {len(assets)} fichier(s)",
    ]
    if body:
        lines.append(f"<i>{_e(body)}</i>")
    lines.append(f"<i>{_reason(notif.reason)}</i>")
    return "\n".join(lines)


def _format_ci(notif: GitHubNotification, d: dict) -> str:
    """Échec CI (CheckSuite ou workflow run)."""
    workflow_raw = d.get("name") or d.get("workflow") or "CI"
    workflow_name = workflow_raw if isinstance(workflow_raw, str) else "CI"
    branch = d.get("head_branch") or ""
    conclusion = d.get("conclusion") or d.get("status") or "?"
    url = d.get("html_url") or _api_to_html_url(notif.subject_url)

    lines = [
        f"❌ <b>CI failed</b> — {_link(notif.repo_full_name, url)}",
        f"<b>{_e(notif.subject_title)}</b>",
        f"Workflow: <code>{_e(workflow_name)}</code>",
    ]
    if branch:
        lines.append(f"Branch: <code>{_e(branch)}</code>")
    lines.append(f"Conclusion: <code>{_e(conclusion)}</code>")
    lines.append(f"<i>{_reason(notif.reason)}</i>")
    return "\n".join(lines)


def _format_security(notif: GitHubNotification, d: dict) -> str:
    """Alerte de sécurité Dependabot."""
    vuln = d.get("security_vulnerability") or {}
    severity = d.get("severity") or (vuln.get("severity") if isinstance(vuln, dict) else "?") or "?"
    pkg = d.get("affected_package_name") or (
        (vuln.get("package") or {}).get("name") if isinstance(vuln, dict) else "?"
    ) or "?"
    patched_raw = (vuln.get("first_patched_version") or {}) if isinstance(vuln, dict) else {}
    patched = patched_raw.get("identifier", "unknown") if isinstance(patched_raw, dict) else str(patched_raw)
    url = d.get("html_url") or _api_to_html_url(notif.subject_url)

    lines = [
        f"🛡️ <b>Security alert</b> — {_link(notif.repo_full_name, url)}",
        f"<b>{_e(notif.subject_title)}</b>",
        f"Severity: <code>{_e(severity)}</code>",
        f"Package: <code>{_e(pkg)}</code>",
        f"Patched in: <code>{_e(patched)}</code>",
        f"<i>{_reason(notif.reason)}</i>",
    ]
    return "\n".join(lines)


def _format_discussion(notif: GitHubNotification, d: dict) -> str:
    """Discussion GitHub."""
    author = (d.get("user") or {}).get("login", "?")
    comments = d.get("comments", 0)
    category = d.get("category") or {}
    cat_name = category.get("name", "") if isinstance(category, dict) else ""
    url = d.get("html_url") or _api_to_html_url(notif.subject_url)

    lines = [
        f"🗣️ <b>Discussion</b> — {_link(notif.repo_full_name, url)}",
        f"<b>{_e(notif.subject_title)}</b>",
        f"By: <b>{_e(author)}</b>",
        f"Comments: {comments}",
    ]
    if cat_name:
        lines.append(f"Category: <i>{_e(cat_name)}</i>")
    lines.append(f"<i>{_reason(notif.reason)}</i>")
    return "\n".join(lines)


def _format_fallback(notif: GitHubNotification) -> str:
    """Format générique pour les types non couverts."""
    url = _api_to_html_url(notif.subject_url) if notif.subject_url else ""
    lines = [
        f"🔔 <b>{_e(notif.subject_type)}</b> — <code>{_e(notif.repo_full_name)}</code>",
        f"<b>{_e(notif.subject_title)}</b>",
        f"<i>{_reason(notif.reason)}</i>",
    ]
    if url:
        lines.append(_link("Voir sur GitHub", url))
    return "\n".join(lines)

# src/telegram_sender.py
import urllib.request
import urllib.error
import json
import logging
from datetime import datetime, timezone, timedelta

import config
from models import GitHubNotification

logger = logging.getLogger(__name__)
TELEGRAM_API = "https://api.telegram.org"
THREAD_TTL_DAYS = 7


def _api_call(token: str, method: str, payload: dict) -> dict:
    """Appel générique à l'API Telegram Bot."""
    url = f"{TELEGRAM_API}/bot{token}/{method}"
    data = json.dumps(payload).encode()
    req = urllib.request.Request(url, data=data, method="POST")
    req.add_header("Content-Type", "application/json")

    try:
        with urllib.request.urlopen(req) as resp:
            return json.loads(resp.read())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        logger.error(f"Telegram API error {e.code} on {method}: {body}")
        raise
    except Exception as e:
        logger.error(f"Unexpected error calling Telegram {method}: {e}")
        raise


def send_message(
    token: str,
    chat_id: str,
    text: str,
    reply_to: int = None,
    inline_keyboard: list = None,
) -> dict:
    """Envoie un message Telegram, retourne la réponse complète."""
    payload = {
        "chat_id": chat_id,
        "text": text,
        "parse_mode": "HTML",
        "disable_web_page_preview": True,
    }
    if reply_to:
        payload["reply_to_message_id"] = reply_to
    if inline_keyboard:
        payload["reply_markup"] = {"inline_keyboard": inline_keyboard}

    return _api_call(token, "sendMessage", payload)


def _load_thread_map() -> dict:
    """Charge le mapping subject_url → {message_id, timestamp} depuis SSM."""
    raw = config.get_state("thread-map", "{}")
    try:
        return json.loads(raw)
    except (json.JSONDecodeError, TypeError):
        return {}


def _save_thread_map(thread_map: dict) -> None:
    config.set_state("thread-map", json.dumps(thread_map))


def get_thread_id(subject_url: str) -> int | None:
    """Retourne le message_id du premier message pour ce sujet, ou None."""
    thread_map = _load_thread_map()
    entry = thread_map.get(subject_url)
    if not entry:
        return None
    return entry.get("message_id")


def save_thread_id(subject_url: str, message_id: int) -> None:
    """Enregistre le message_id pour ce sujet et nettoie les entrées périmées."""
    thread_map = _load_thread_map()
    thread_map = _cleanup_old_threads(thread_map)
    thread_map[subject_url] = {
        "message_id": message_id,
        "timestamp": datetime.now(timezone.utc).isoformat(),
    }
    _save_thread_map(thread_map)


def _cleanup_old_threads(thread_map: dict) -> dict:
    """Supprime les entrées vieilles de plus de THREAD_TTL_DAYS jours."""
    cutoff = datetime.now(timezone.utc) - timedelta(days=THREAD_TTL_DAYS)
    cleaned = {}
    for url, entry in thread_map.items():
        try:
            ts = datetime.fromisoformat(entry["timestamp"].replace("Z", "+00:00"))
            if ts > cutoff:
                cleaned[url] = entry
        except Exception:
            pass  # entrée malformée → on la supprime
    return cleaned


def send_notification(
    notif: GitHubNotification,
    text: str,
    token: str,
    chat_id: str,
) -> None:
    """
    Envoie une notification.
    Si une notification précédente existe pour ce sujet, répond en thread.
    """
    reply_to = get_thread_id(notif.subject_url) if notif.subject_url else None

    try:
        resp = send_message(token, chat_id, text, reply_to=reply_to)
        if resp.get("ok") and notif.subject_url and not reply_to:
            # Premier message pour ce sujet : on sauvegarde l'ID pour les suivants
            message_id = resp["result"]["message_id"]
            save_thread_id(notif.subject_url, message_id)
    except Exception as e:
        logger.error(f"Erreur envoi notification {notif.id}: {e}")

# src/telegram_commands.py
import logging
from datetime import datetime, timezone

import config
from telegram_sender import send_message

logger = logging.getLogger(__name__)


def parse_update(body: dict) -> dict | None:
    """
    Extrait les informations utiles d'un update Telegram.
    Retourne un dict {type, text, data} ou None si l'update est ignoré.
    """
    if not isinstance(body, dict):
        return None

    # Message classique (commande /xxx)
    if "message" in body:
        msg = body["message"]
        text = msg.get("text", "")
        if text.startswith("/"):
            return {"type": "command", "text": text.strip()}

    # Callback query (bouton inline)
    if "callback_query" in body:
        cq = body["callback_query"]
        return {"type": "callback", "data": cq.get("data", ""), "id": cq.get("id")}

    return None


def handle_command(update: dict, token: str, chat_id: str) -> None:
    """Dispatch une commande ou un callback vers le bon handler."""
    if update["type"] == "callback":
        _handle_callback(update, token, chat_id)
        return

    text = update["text"]
    parts = text.split()
    command = parts[0].lower().split("@")[0]  # /mute@botname → /mute
    args = parts[1:] if len(parts) > 1 else []

    handlers = {
        "/help": _cmd_help,
        "/status": _cmd_status,
        "/mute": _cmd_mute,
        "/unmute": _cmd_unmute,
        "/list": _cmd_list,
        "/pause": _cmd_pause,
        "/resume": _cmd_resume,
    }

    handler = handlers.get(command)
    if handler:
        handler(args, token, chat_id)
    else:
        send_message(token, chat_id, f"Commande inconnue : <code>{command}</code>\nTape /help pour la liste.")


def _handle_callback(update: dict, token: str, chat_id: str) -> None:
    """Gère les callbacks des boutons inline."""
    data = update.get("data", "")
    if data == "pause":
        _cmd_pause([], token, chat_id)


def _cmd_help(args, token, chat_id):
    text = (
        "🤖 <b>GitHub Notifier — Commandes disponibles</b>\n\n"
        "/status — État du bot (dernier poll, rate limit)\n"
        "/mute owner/repo — Mute un repo\n"
        "/unmute owner/repo — Unmute un repo\n"
        "/list — Liste des repos mutés\n"
        "/pause — Pause le polling (les notifs s'accumulent sur GitHub)\n"
        "/resume — Reprend le polling\n"
        "/help — Affiche ce message"
    )
    send_message(token, chat_id, text)


def _cmd_status(args, token, chat_id):
    last_poll = config.get_state("last-poll-timestamp", "jamais")
    rate_remaining = config.get_state("rate-limit-remaining", "?")
    rate_reset_ts = config.get_state("rate-limit-reset", "")
    paused = config.get_state("paused", "false")
    crash_count = config.get_state("crash-count", "0")

    # Calcul du délai depuis le dernier poll
    delay_str = ""
    if last_poll != "jamais":
        try:
            last_dt = datetime.fromisoformat(last_poll.replace("Z", "+00:00"))
            delta = datetime.now(timezone.utc) - last_dt
            days = delta.days
            hours, rem = divmod(delta.seconds, 3600)
            mins, _ = divmod(rem, 60)
            if days > 0:
                delay_str = f"{days}j {hours}h"
            elif hours > 0:
                delay_str = f"{hours}h {mins}m"
            else:
                delay_str = f"{mins}m"
        except Exception:
            delay_str = "?"

    status_emoji = "⏸️" if paused.lower() == "true" else "✅"
    crash_emoji = "🔴" if int(crash_count) > 0 else "✅"

    text = (
        f"{status_emoji} <b>État du bot</b>\n\n"
        f"Statut: {'<b>En pause</b>' if paused.lower() == 'true' else 'Actif'}\n"
        f"Dernier poll: {delay_str or last_poll}\n"
        f"Rate limit restant: <code>{rate_remaining}</code> req/h\n"
        f"{crash_emoji} Crashes consécutifs: {crash_count}"
    )
    send_message(token, chat_id, text)


def _cmd_mute(args, token, chat_id):
    if not args:
        send_message(token, chat_id, "Usage: /mute owner/repo")
        return
    repo = args[0]
    if "/" not in repo:
        send_message(token, chat_id, "Format attendu: owner/repo (ex: /mute torvalds/linux)")
        return

    muted = config.get_muted_repos()
    if repo in muted:
        send_message(token, chat_id, f"<code>{repo}</code> est déjà muté.")
        return

    muted.append(repo)
    config.set_muted_repos(muted)
    send_message(token, chat_id, f"🔇 <code>{repo}</code> muté. Tu ne recevras plus de notifications pour ce repo.")


def _cmd_unmute(args, token, chat_id):
    if not args:
        send_message(token, chat_id, "Usage: /unmute owner/repo")
        return
    repo = args[0]
    muted = config.get_muted_repos()

    if repo not in muted:
        send_message(token, chat_id, f"<code>{repo}</code> n'est pas dans la liste des repos mutés.")
        return

    muted.remove(repo)
    config.set_muted_repos(muted)
    send_message(token, chat_id, f"🔔 <code>{repo}</code> démuté.")


def _cmd_list(args, token, chat_id):
    muted = config.get_muted_repos()
    if not muted:
        send_message(token, chat_id, "Aucun repo muté.")
        return

    repos_str = "\n".join(f"• <code>{r}</code>" for r in muted)
    send_message(token, chat_id, f"🔇 <b>Repos mutés :</b>\n{repos_str}")


def _cmd_pause(args, token, chat_id):
    config.set_state("paused", "true")
    send_message(
        token,
        chat_id,
        "⏸️ Bot en pause. Les notifications s'accumulent sur GitHub.\n"
        "Tape /resume pour reprendre (toutes les notifs en attente seront envoyées).",
    )


def _cmd_resume(args, token, chat_id):
    config.set_state("paused", "false")
    send_message(token, chat_id, "▶️ Bot repris. Prochain poll dans 2 minutes.")

# src/dedup.py
import html as _html
from models import GitHubNotification
from formatters import REASON_LABELS, _e, _link, _api_to_html_url


def group_notifications(notifications: list[GitHubNotification]) -> list[list[GitHubNotification]]:
    """
    Regroupe les notifications par subject_url.
    Retourne une liste de groupes, chaque groupe = liste de notifications sur le même sujet.
    """
    seen: dict[str, list[GitHubNotification]] = {}
    order: list[str] = []

    for notif in notifications:
        key = notif.subject_url or notif.id
        if key not in seen:
            seen[key] = []
            order.append(key)
        seen[key].append(notif)

    return [seen[k] for k in order]


def format_grouped(notifs: list[GitHubNotification]) -> str:
    """
    Format condensé pour plusieurs notifications sur le même sujet.
    Ex: 3 activités sur la PR #42
    """
    first = notifs[0]
    url = _api_to_html_url(first.subject_url) if first.subject_url else ""
    count = len(notifs)

    repo_link = _link(first.repo_full_name, url) if url else f"<code>{_e(first.repo_full_name)}</code>"

    lines = [
        f"🔔 <b>{count} nouvelles activités</b> — {repo_link}",
        f"<b>{_e(first.subject_title)}</b>",
        "",
    ]

    for notif in notifs:
        reason_label = REASON_LABELS.get(notif.reason, f"🔔 {notif.reason}")
        lines.append(f"• {reason_label}")

    return "\n".join(lines)

# src/monitoring.py
import logging
import config
from telegram_sender import send_message

logger = logging.getLogger(__name__)

RATE_LIMIT_ALERT_THRESHOLD = 500
CRASH_ALERT_THRESHOLD = 3


def check_rate_limit(remaining: int, token: str, chat_id: str) -> None:
    """Alerte si le rate limit GitHub est sous le seuil."""
    if remaining > RATE_LIMIT_ALERT_THRESHOLD:
        return

    logger.warning(f"Rate limit bas : {remaining} requêtes restantes")

    # Bouton inline pour mettre en pause d'un clic
    keyboard = [[{
        "text": "⏸️ Pause le bot",
        "callback_data": "pause",
    }]]

    text = (
        f"⚠️ <b>Rate limit GitHub bas</b>\n\n"
        f"Il reste <b>{remaining}</b> requêtes sur 5 000.\n"
        f"Le bot sera bloqué si le quota tombe à 0.\n\n"
        f"Tu peux mettre le bot en pause pour économiser le quota "
        f"(les notifs s'accumulent sur GitHub et seront envoyées au resume)."
    )

    try:
        send_message(token, chat_id, text, inline_keyboard=keyboard)
    except Exception as e:
        logger.error(f"Impossible d'envoyer l'alerte rate limit: {e}")


def increment_crash_counter() -> int:
    """Incrémente le crash counter et retourne la nouvelle valeur."""
    current = int(config.get_state("crash-count", "0"))
    new_count = current + 1
    config.set_state("crash-count", str(new_count))
    logger.error(f"Crash counter: {new_count}")
    return new_count


def reset_crash_counter() -> None:
    """Remet le crash counter à 0 après un succès."""
    current = config.get_state("crash-count", "0")
    if current != "0":
        config.set_state("crash-count", "0")


def alert_crash(count: int) -> None:
    """Envoie une alerte Telegram après N crashes consécutifs."""
    try:
        token = config.get_telegram_token()
        chat_id = config.get_telegram_chat_id()
        text = (
            f"🔴 <b>Lambda en échec</b>\n\n"
            f"La Lambda a crashé <b>{count} fois de suite</b>.\n"
            f"Vérifie les logs CloudWatch pour diagnostiquer.\n\n"
            f"<code>aws logs tail /aws/lambda/github-notifier --follow</code>"
        )
        send_message(token, chat_id, text)
    except Exception as e:
        logger.error(f"Impossible d'envoyer l'alerte crash: {e}")