events/services.py

from __future__ import annotations

import asyncio
import re
import smtplib
from asyncio.tasks import create_task
from email.mime.image import MIMEImage
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.utils import formataddr, formatdate, make_msgid
from html import escape

from lnbits.core.models.users import UserNotifications
from lnbits.core.services.nostr import send_nostr_dm
from lnbits.core.services.notifications import send_user_notification
from lnbits.helpers import is_valid_email_address
from lnbits.settings import settings
from lnbits.utils.nostr import normalize_private_key, normalize_public_key
from lnurl import execute
from loguru import logger

from .crud import (
    get_event,
    get_event_tickets,
    purge_unpaid_tickets,
    update_event,
    update_ticket,
)
from .models import (
    Event,
    NotificationDeliveryResult,
    Ticket,
    TicketResendResult,
    ensure_ticket_waves,
)
from .nostr_hooks import publish_or_delete_nostr_event
from .promo import promo_usage
from .qr import (
    format_event_when,
    image_png_bytes,
    load_qr_logo,
    render_ticket_card,
    ticket_card_filename,
)

DEFAULT_NOSTR_RELAYS = [
    "wss://relay.damus.io",
    "wss://relay.primal.net",
    "wss://relay.nostr.band",
]

# Per-event lock: serializes the counter-update + Nostr republish for a
# single event_id so two paid invoices landing on the listener queue back-
# to-back can't reorder the published state. Lazy-populated; entries are
# left in memory for the lifetime of the process (cheap — one asyncio.Lock
# object per event ever sold).
_event_paid_locks: dict[str, asyncio.Lock] = {}


def _event_paid_lock(event_id: str) -> asyncio.Lock:
    lock = _event_paid_locks.get(event_id)
    if lock is None:
        lock = asyncio.Lock()
        _event_paid_locks[event_id] = lock
    return lock


async def set_ticket_paid(ticket: Ticket) -> Ticket:
    if ticket.paid:
        return ticket

    async with _event_paid_lock(ticket.event):
        ticket.paid = True
        await update_ticket(ticket)

        event = await get_event(ticket.event)
        assert event, "Couldn't get event from ticket being paid"
        event.sold += 1
        # Debit the wave the buyer actually bought from. v1.6.8 moved
        # inventory onto waves; the event-level counter is only the
        # fallback for events that predate them, and is itself a derived
        # roll-up (`sync_event_ticket_waves`). Upstream's `> 0` guards are
        # kept — ours decremented unconditionally and could go negative.
        ticket_waves = event.extra.ticket_waves or []
        if ticket_waves:
            selected_wave = next(
                (
                    wave
                    for wave in ticket_waves
                    if wave.id == ticket.extra.ticket_wave_id
                ),
                ticket_waves[0],
            )
            if selected_wave.amount_tickets > 0:
                selected_wave.amount_tickets -= 1
        elif event.amount_tickets > 0:
            event.amount_tickets -= 1
        # Flag inside this same write: the counters and "the relay does
        # not know about them yet" land atomically, so a crash between
        # here and the publish still leaves the drift discoverable.
        event.nostr_publish_pending = True
        await update_event(event)

        # Republish the NIP-52 calendar event so connected clients see
        # the new tickets_available / tickets_sold counters via their
        # existing relay subscription. Failures are logged + swallowed
        # inside publish_or_delete_nostr_event so a Nostr outage doesn't
        # break the payment flow.
        await publish_or_delete_nostr_event(event)

    return ticket


async def event_promo_usage(event_id: str) -> dict[str, int]:
    """Paid redemptions per promo code for one event (see promo.promo_usage)."""
    return promo_usage(await get_event_tickets(event_id))


async def hydrate_promo_usage(event: Event) -> Event:
    """Fill `used_count` on each of the event's promo codes. No query when
    the event has no codes, so listing stays cheap."""
    if not event.extra.promo_codes:
        return event
    usage = await event_promo_usage(event.id)
    for promo in event.extra.promo_codes:
        promo.used_count = usage.get(promo.code, 0)
    return event


def send_ticket_notification_in_background(ticket: Ticket) -> None:
    create_task(_send_ticket_notification(ticket))


async def _send_ticket_notification(ticket: Ticket) -> None:
    event = await get_event(ticket.event)
    if not event:
        logger.warning(f"Event {ticket.event} not found for ticket notification.")
        return

    await _deliver_ticket_notifications(ticket, event)


async def resend_ticket_email_notification(
    ticket: Ticket, base_url: str | None = None
) -> TicketResendResult:
    """Organizer-triggered re-delivery of the ticket email. Bypasses the
    per-event `email_notifications` opt-in (the organizer asked explicitly)
    but still needs the instance mailer and an address on the ticket.

    `base_url` is upstream v1.6.8's: it re-points the ticket link at the
    caller's frontend, which matters for us specifically because our
    `ticket_base_url` can differ from `lnbits_baseurl` (separate web app).
    """
    event = await get_event(ticket.event)
    if not event:
        raise ValueError("Event does not exist.")
    if not settings.lnbits_email_notifications_enabled:
        raise ValueError("Email notifications are not enabled.")
    if not ticket.email:
        raise ValueError("Ticket does not have an email address.")
    if base_url:
        ticket.extra.ticket_base_url = base_url.rstrip("/")

    # email-only: this is the *email* resend endpoint. Upstream calls
    # `_deliver_ticket_notifications(ticket, event)` unqualified, which in
    # our fork would also fire a Nostr DM the organiser did not ask for.
    return await _deliver_ticket_notifications(ticket, event, email=True, nostr=False)


def _ticket_notification_message(ticket: Ticket, event: Event) -> tuple[str, str]:
    ticket_url = _ticket_url(ticket)
    subject = (
        event.extra.notification_subject.strip()
        or f"Your ticket for '{event.name}' is ready"
    )
    body = (
        event.extra.notification_body.strip()
        or f"Your ticket for '{event.name}' is ready."
    )

    return subject, f"{body}\n\nOpen it here: {ticket_url}"


def _ticket_details(ticket: Ticket, event: Event) -> str:
    """Human-readable ticket facts for the email body. Also what keeps the
    mail from being an image with no words (SpamAssassin HTML_IMAGE_ONLY)."""
    lines = [f"Event: {event.name}", f"When: {format_event_when(event)}"]
    if event.location:
        lines.append(f"Where: {event.location}")
    if ticket.name:
        lines.append(f"Name on ticket: {ticket.name}")
    lines.append(f"Ticket ID: {ticket.id}")
    lines.append(
        "Your ticket (with its QR code) is attached to this email — save it "
        "or open the link above on your phone, and show the QR code at the "
        "door to be scanned in."
    )
    return "\n".join(lines)


def _ticket_delivery_message(ticket: Ticket, event: Event, base_message: str) -> str:
    """Text part of the ticket mail.

    Carries up to two images, which are NOT the same thing (see the note on
    `_ticket_card_url` vs `_ticket_image_url`): our rendered QR card, always
    present, and the organiser's uploaded template, only when the buyer's
    wave opted into it. They had the same label before the v1.6.8 merge
    because only one of them existed; now that both can appear the labels
    have to distinguish them.
    """
    message = (
        f"{base_message}\n\n{_ticket_details(ticket, event)}"
        f"\n\nTicket card: {_ticket_card_url(ticket)}"
    )
    ticket_image_url = _ticket_image_url(ticket, event)
    if ticket_image_url:
        message = f"{message}\n\nTicket image: {ticket_image_url}"
    return message


def _ticket_email_html_message(ticket: Ticket, event: Event, base_message: str) -> str:
    """HTML twin of the text part.

    Deliberately no <img> for our own ticket card: it travels as an
    attachment (renders inline in most clients, works offline, and keeps
    SpamAssassin's HTML_IMAGE_ONLY rules quiet), and its URL becomes a link.
    The organiser's uploaded ticket image is a remote URL with no attachment
    to fall back on, so that one does get upstream's <img> — the surrounding
    ticket details keep the mail from being image-only either way.
    """
    text_message = _ticket_delivery_message(ticket, event, base_message)
    html = escape(text_message)
    html = re.sub(
        r"(https?://[^\s<]+)",
        lambda m: f'<a href="{m.group(1)}">{m.group(1)}</a>',
        html,
    )
    html_message = f"<p>{html.replace(chr(10), '<br />')}</p>"

    ticket_image_url = _ticket_image_url(ticket, event)
    if not ticket_image_url:
        return html_message

    return (
        f"{html_message}"
        f'<p><img src="{escape(ticket_image_url, quote=True)}" alt="Ticket image" '
        'style="max-width: 200px; height: auto;" /></p>'
    )


def _ticket_notification_payload(ticket: Ticket, event: Event) -> tuple[str, str, str]:
    subject, base_message = _ticket_notification_message(ticket, event)
    text_message = _ticket_delivery_message(ticket, event, base_message)
    html_message = _ticket_email_html_message(ticket, event, base_message)
    return subject, text_message, html_message


async def _deliver_ticket_notifications(
    ticket: Ticket,
    event: Event,
    *,
    email: bool | None = None,
    nostr: bool | None = None,
) -> TicketResendResult:
    """Send the ticket by every configured channel and report per-channel
    outcome (upstream v1.6.8 shape). `email` / `nostr` override the event's
    opt-ins when not None; the instance-level prerequisites always apply.

    Upstream v1.6.8 guards the nostr branch with a `_supports_nostr_delivery`
    check that errors with "Only NIP-05 Nostr identifiers are supported."
    That guard is NOT taken here: it encodes upstream's limitation, not ours.
    `_send_nostr_ticket_notification` below dispatches NIP-05 identifiers to
    core's notifier and bare npubs to `send_nostr_dm`, so adopting the guard
    would silently refuse identifiers we deliver to today — and say so with
    a message that would be false for this fork.
    """
    subject, text_message, html_message = _ticket_notification_payload(ticket, event)
    updated = False

    email_wanted = event.extra.email_notifications if email is None else email
    nostr_wanted = event.extra.nostr_notifications if nostr is None else nostr
    result = TicketResendResult(
        ticket=ticket,
        email=NotificationDeliveryResult(
            attempted=bool(
                email_wanted
                and settings.lnbits_email_notifications_enabled
                and ticket.email
            )
        ),
        nostr=NotificationDeliveryResult(
            attempted=bool(
                nostr_wanted
                and settings.is_nostr_notifications_configured()
                and ticket.extra.nostr_identifier
            )
        ),
    )

    if result.email.attempted:
        try:
            assert ticket.email
            card = render_ticket_card(
                ticket,
                event,
                logo=await load_qr_logo(),
                site_title=settings.lnbits_site_title,
            )
            await _send_ticket_email_notification(
                [ticket.email],
                text_message,
                subject,
                html_message,
                attachments=[
                    (ticket_card_filename(ticket, event), image_png_bytes(card))
                ],
            )
            ticket.extra.email_notification_sent = True
            result.email.sent = True
            updated = True
        except Exception as exc:
            logger.warning(f"Failed to email ticket {ticket.id}: {exc}")
            result.email.error = str(exc)

    if result.nostr.attempted:
        try:
            identifier = ticket.extra.nostr_identifier
            assert identifier
            await _send_nostr_ticket_notification(identifier, text_message)
            ticket.extra.nostr_notification_sent = True
            result.nostr.sent = True
            updated = True
        except Exception as exc:
            logger.warning(f"Failed to send nostr DM for ticket {ticket.id}: {exc}")
            result.nostr.error = str(exc)

    if updated:
        result.ticket = await update_ticket(ticket)
    return result


async def _send_ticket_email_notification(
    to_emails: list[str],
    message: str,
    subject: str,
    html_message: str | None = None,
    attachments: list[tuple[str, bytes]] | None = None,
) -> None:
    """Multipart (text + HTML) ticket email through the instance SMTP
    settings. Core's `send_email_notification` is plain-text only, which is
    why this lives here (ported from upstream v1.6.8). The blocking smtplib
    session runs in a worker thread so a slow relay cannot stall the event
    loop while a batch of tickets settles."""
    if not settings.lnbits_email_notifications_enabled:
        raise ValueError("Email notifications are disabled")
    from_email = settings.lnbits_email_notifications_email
    if not is_valid_email_address(from_email):
        raise ValueError(f"Invalid from email address: {from_email}")
    if not to_emails:
        raise ValueError("No email addresses provided")
    for address in to_emails:
        if not is_valid_email_address(address):
            raise ValueError(f"Invalid email address: {address}")

    msg = build_ticket_email(
        from_email, to_emails, subject, message, html_message, attachments
    )
    username = settings.lnbits_email_notifications_username or from_email
    await asyncio.to_thread(
        _smtp_send,
        settings.lnbits_email_notifications_server,
        settings.lnbits_email_notifications_port,
        username,
        settings.lnbits_email_notifications_password,
        from_email,
        to_emails,
        msg.as_string(),
    )


def build_ticket_email(
    from_email: str,
    to_emails: list[str],
    subject: str,
    message: str,
    html_message: str | None = None,
    attachments: list[tuple[str, bytes]] | None = None,
) -> MIMEMultipart:
    """Assemble the ticket email: text + HTML alternatives, PNG attachments
    (the ticket card), and the headers receivers score on — a Date and a
    Message-ID (their absence is what SpamAssassin's MISSING_DATE /
    MISSING_MID flag, and what Gmail/Outlook read as machine-generated) and
    a display name on From so the sender is not a bare address."""
    body = MIMEMultipart("alternative")
    body.attach(MIMEText(message, "plain"))
    if html_message:
        body.attach(MIMEText(html_message, "html"))

    if attachments:
        msg = MIMEMultipart("mixed")
        msg.attach(body)
        for filename, data in attachments:
            part = MIMEImage(data, _subtype="png")
            part.add_header("Content-Disposition", "attachment", filename=filename)
            msg.attach(part)
    else:
        msg = body

    sender_name = (settings.lnbits_site_title or "").strip() or "Tickets"
    msg["From"] = formataddr((sender_name, from_email))
    msg["To"] = ", ".join(to_emails)
    msg["Subject"] = subject
    msg["Date"] = formatdate(localtime=True)
    msg["Message-ID"] = make_msgid(domain=from_email.rsplit("@", 1)[-1])
    return msg


def _smtp_send(
    server: str,
    port: int,
    username: str,
    password: str,
    from_email: str,
    to_emails: list[str],
    payload: str,
) -> None:
    with smtplib.SMTP(server, port, timeout=30) as smtp_server:
        smtp_server.starttls()
        smtp_server.login(username, password)
        smtp_server.sendmail(from_email, to_emails, payload)


async def _send_nostr_ticket_notification(identifier: str, message: str) -> None:
    if "@" in identifier:
        await send_user_notification(
            UserNotifications(nostr_identifier=identifier),
            message,
            "text_message",
        )
        return

    private_key = normalize_private_key(settings.lnbits_nostr_notifications_private_key)
    public_key = normalize_public_key(identifier)
    await send_nostr_dm(private_key, public_key, message, DEFAULT_NOSTR_RELAYS)


def _ticket_url(ticket: Ticket) -> str:
    base_url = (ticket.extra.ticket_base_url or settings.lnbits_baseurl).rstrip("/")
    return f"{base_url}/events/ticket/{ticket.id}"


def _ticket_card_url(ticket: Ticket) -> str:
    """Our rendered ticket-card PNG — always available, and served by THIS
    extension on the LNbits host, so it is built from `lnbits_baseurl` even
    when `ticket_base_url` points at a separate web app (deviation from
    upstream, which assumes both are the same host)."""
    return (
        f"{settings.lnbits_baseurl.rstrip('/')}/events/api/v1/ticket-card/{ticket.id}"
    )


def _ticket_image_url(ticket: Ticket, event: Event) -> str | None:
    """Upstream's organiser-uploaded ticket template, opted into per wave.

    Distinct from `_ticket_card_url`: that is our own rendered card and is
    always attached, this is a template the organiser uploads and enables
    on a specific wave. They shared a name before the v1.6.8 merge, which
    made them look like one feature.
    """
    waves = ensure_ticket_waves(event)
    wave = next(
        (wave for wave in waves if wave.id == ticket.extra.ticket_wave_id),
        waves[0],
    )
    if not wave.use_ticket_image:
        return None

    base_url = (ticket.extra.ticket_base_url or settings.lnbits_baseurl).rstrip("/")
    return f"{base_url}/events/api/v1/qr/{ticket.id}"


async def refund_tickets(event_id: str):
    """
    Refund tickets for an event that has not met the minimum ticket requirement.
    This function should be called when the event is closed and the minimum ticket
    condition is not met.
    """
    await purge_unpaid_tickets(event_id)
    tickets = await get_event_tickets(event_id)

    if not tickets:
        return

    for ticket in tickets:
        if ticket.extra.refunded:
            continue
        if ticket.paid and ticket.extra.refund_address and ticket.extra.sats_paid:
            try:
                res = await execute(
                    ticket.extra.refund_address, str(ticket.extra.sats_paid)
                )
                if res:
                    ticket.extra.refunded = True
                    await update_ticket(ticket)
            except Exception as e:
                logger.error(f"Error refunding ticket {ticket.id}: {e}")