events/nostr_publisher.py

"""
NIP-52 calendar event publishing for the events extension.

Builds NIP-52 calendar events from the Event model, signs them with the
creator's Account keypair, and publishes via the NostrClient.

Kind 31922 is used for date-only events; kind 31923 (time-based) is used
when event_start_date / event_end_date include a time component.

Reference: https://github.com/nostr-protocol/nips/blob/master/52.md
"""

import time
from datetime import datetime, timezone

import coincurve
from loguru import logger

from .models import Event
from .nostr.event import NostrEvent


def _has_time(value: str | None) -> bool:
    """ISO 8601 datetime strings contain a 'T' between date and time."""
    return value is not None and "T" in value


def _to_unix(value: str) -> int:
    """Parse ISO 8601 datetime (assume UTC if naive) to unix seconds."""
    dt = datetime.fromisoformat(value)
    if dt.tzinfo is None:
        dt = dt.replace(tzinfo=timezone.utc)
    return int(dt.timestamp())


def build_nip52_event(event: Event, pubkey: str) -> NostrEvent:
    """
    Convert an Event model to a NIP-52 calendar event.

    Time-based (kind 31923) if event_start_date carries an HH:MM, otherwise
    date-based (kind 31922). Tags:
      d       - event.id
      title   - event.name
      start   - unix timestamp (31923) or YYYY-MM-DD (31922)
      end     - same encoding (optional)
      image, location, t (categories) - optional
    Content:  event.info
    """
    time_based = _has_time(event.event_start_date)
    kind = 31923 if time_based else 31922
    start_value = (
        str(_to_unix(event.event_start_date)) if time_based else event.event_start_date
    )

    tags = [
        ["d", event.id],
        ["title", event.name],
        ["start", start_value],
    ]

    end_unix: int | None = None
    if event.event_end_date:
        end_value = (
            str(_to_unix(event.event_end_date)) if time_based else event.event_end_date
        )
        tags.append(["end", end_value])
        if time_based:
            end_unix = _to_unix(event.event_end_date)

    if time_based:
        start_unix = _to_unix(event.event_start_date)
        start_day = start_unix // 86400
        end_day = (end_unix // 86400) if end_unix is not None else start_day
        for day in range(start_day, end_day + 1):
            tags.append(["D", str(day)])

    if event.banner:
        tags.append(["image", event.banner])
    if event.location:
        tags.append(["location", event.location])
    for cat in event.categories or []:
        tags.append(["t", cat])

    nostr_event = NostrEvent(
        pubkey=pubkey,
        created_at=int(time.time()),
        kind=kind,
        tags=tags,
        content=event.info or "",
    )
    nostr_event.id = nostr_event.event_id
    return nostr_event


def build_nip52_delete_event(event: Event, pubkey: str) -> NostrEvent:
    """
    Build a kind 5 delete event for a published NIP-52 calendar event.

    Uses an 'a' tag to reference the parameterized replaceable event per
    NIP-09. The referenced kind must match what we published — 31923 for
    time-based events, 31922 for date-only.
    """
    referenced_kind = 31923 if _has_time(event.event_start_date) else 31922
    nostr_event = NostrEvent(
        pubkey=pubkey,
        created_at=int(time.time()),
        kind=5,
        tags=[
            ["a", f"{referenced_kind}:{pubkey}:{event.id}"],
        ],
        content="Event canceled",
    )
    nostr_event.id = nostr_event.event_id
    return nostr_event


def sign_nostr_event(nostr_event: NostrEvent, private_key_hex: str) -> None:
    """Sign a NostrEvent in-place using Schnorr signature."""
    privkey = coincurve.PrivateKey(bytes.fromhex(private_key_hex))
    sig = privkey.sign_schnorr(bytes.fromhex(nostr_event.id))
    nostr_event.sig = sig.hex()


async def publish_event_to_nostr(
    nostr_client,
    event: Event,
    account_pubkey: str,
    account_prvkey: str,
    delete: bool = False,
) -> NostrEvent | None:
    """
    Build, sign, and publish a NIP-52 calendar event (or delete event).

    Returns the published NostrEvent for metadata storage, or None on failure.
    """
    if not nostr_client:
        logger.debug("[EVENTS] No NostrClient available, skipping publish")
        return None

    try:
        if delete:
            nostr_event = build_nip52_delete_event(event, account_pubkey)
        else:
            nostr_event = build_nip52_event(event, account_pubkey)

        sign_nostr_event(nostr_event, account_prvkey)
        await nostr_client.publish_nostr_event(nostr_event)

        logger.info(
            f"[EVENTS] Published NIP-52 {'delete' if delete else 'calendar'} "
            f"event: {nostr_event.id[:16]}... (kind {nostr_event.kind})"
        )
        return nostr_event

    except Exception as e:
        logger.warning(f"[EVENTS] Failed to publish to Nostr: {e}")
        return None