"""Outgoing webhooks: enqueue, HMAC signature, delivery with retries (TZ 2.8.8)."""

from __future__ import annotations

import hashlib
import hmac
import json
import logging
import random
import time
from datetime import timedelta
from typing import Any

from django.db import transaction
from django.utils import timezone

from snapfile.core import ids
from snapfile.core.crypto import decrypt_secret
from snapfile.core.http import FetchError, request
from snapfile.core.ids import uuid7
from snapfile.projects.models import Project

from .models import WebhookDelivery
from .queue import JobQueue

log = logging.getLogger("snapfile.webhook")
EVENTS = (
    "render.succeeded",
    "render.failed",
    "render.batch.completed",
    "template.published",
    "template.version.activated",
    "edit_session.revoked",
)
RETRY_SCHEDULE = (60, 300, 900, 3600, 10800, 21600, 43200, 86400)
MAX_ATTEMPTS = len(RETRY_SCHEDULE)
queue = JobQueue(WebhookDelivery)


def signature(secret: str, timestamp: int, body: bytes) -> str:
    return "v1=" + hmac.new(secret.encode(), f"{timestamp}.".encode() + body, hashlib.sha256).hexdigest()


def enqueue_event(project: Project, event: str, data: dict[str, Any], url: str | None = None) -> None:
    """Create a delivery after the surrounding transaction commits (no-op without a URL)."""
    target = url
    if not target:
        # Project-level subscription: honour the enabled flag and the event filter (Integration page).
        if not project.webhook_url or project.setting("webhook_enabled") is False:
            return
        events = project.setting("webhook_events")
        if isinstance(events, list) and events and event not in events:
            return
        target = project.webhook_url
    event_uuid = uuid7()
    payload = {
        "id": ids.encode("evt", event_uuid),
        "type": event,
        "created_at": timezone.now().isoformat(),
        "project": project.slug,
        "data": data,
    }

    def create() -> None:
        WebhookDelivery.objects.create(
            project=project,
            event=event,
            event_id=payload["id"],
            url=target,
            payload=payload,
            queue="webhooks",
            priority=5,
            max_attempts=MAX_ATTEMPTS,
        )

    transaction.on_commit(create)


def deliver(delivery: WebhookDelivery, owner: str) -> str:
    project = delivery.project
    secret = decrypt_secret(project.webhook_secret_enc) or ""
    body = json.dumps(delivery.payload, ensure_ascii=False, separators=(",", ":")).encode()
    ts = int(time.time())
    headers = {
        "Content-Type": "application/json",
        "X-Snapfile-Event": delivery.event,
        "X-Snapfile-Delivery": ids.encode("dlv", delivery.id) or "",
        "X-Snapfile-Timestamp": str(ts),
        "X-Snapfile-Signature": signature(secret, ts, body),
    }
    now = timezone.now()
    try:
        res = request("POST", delivery.url, body=body, headers=headers, timeout=10.0, max_bytes=64 * 1024)
        code, snippet = res.status, res.data[:500].decode("utf-8", "replace")
    except FetchError as exc:
        code, snippet = 0, f"{exc.code}: {exc}"[:500]
    if 200 <= code < 300:
        queue.finish(
            delivery.pk,
            owner,
            status="succeeded",
            response_code=code,
            response_snippet=snippet,
            delivered_at=now,
            lease_owner=None,
        )
        return "succeeded"
    stop = code == 410 or delivery.attempts >= delivery.max_attempts
    if stop:
        queue.finish(
            delivery.pk,
            owner,
            status="failed",
            response_code=code or None,
            response_snippet=snippet,
            error_code="WEBHOOK_GONE" if code == 410 else "WEBHOOK_FAILED",
            lease_owner=None,
        )
        return "failed"
    delay = RETRY_SCHEDULE[min(delivery.attempts, len(RETRY_SCHEDULE)) - 1] * random.uniform(0.8, 1.2)
    queue.finish(
        delivery.pk,
        owner,
        status="queued",
        response_code=code or None,
        response_snippet=snippet,
        available_at=now + timedelta(seconds=delay),
        lease_owner=None,
        lease_until=None,
        error_code="WEBHOOK_RETRY",
    )
    log.info("webhook retry scheduled", extra={"event": "webhook.retry", "delivery": str(delivery.pk), "code": code})
    return "queued"


def send_test_event(project: Project) -> dict[str, Any]:
    """Synchronous ``webhook.test`` delivery to the project URL (Integration page, "Send test")."""
    if not project.webhook_url:
        return {"delivered": False, "status": None, "error": "NO_URL"}
    payload = {
        "id": ids.encode("evt", uuid7()),
        "type": "webhook.test",
        "created_at": timezone.now().isoformat(),
        "project": project.slug,
        "data": {"message": "Test event from Snapfile"},
    }
    body = json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode()
    ts = int(time.time())
    headers = {
        "Content-Type": "application/json",
        "X-Snapfile-Event": "webhook.test",
        "X-Snapfile-Delivery": payload["id"],
        "X-Snapfile-Timestamp": str(ts),
        "X-Snapfile-Signature": signature(decrypt_secret(project.webhook_secret_enc) or "", ts, body),
    }
    try:
        res = request("POST", project.webhook_url, body=body, headers=headers, timeout=10.0, max_bytes=64 * 1024)
    except FetchError as exc:
        return {"delivered": False, "status": None, "error": exc.code}
    return {"delivered": 200 <= res.status < 300, "status": res.status}
