"""
catalog_app/services/newsletter_service.py
────────────────────────────────────────────
Newsletter composition, rendering, and sending.

Rendering is pure (never sends anything) — render_newsletter_html() /
render_newsletter_text() are reused identically by preview, "send test",
and the real bulk send, so what staff preview is exactly what gets
delivered.

Sending is chunked and resumable rather than queue-based — this project has
no task queue, and at this subscriber-list scale a Newsletter row's own
status/sent_count/send_cursor_subscriber_id fields ARE the queue state. See
send_newsletter_chunked().
"""

import html as html_module
import logging
import time

import bleach
from django.conf import settings
from django.core.mail import EmailMultiAlternatives, get_connection
from django.template.loader import render_to_string
from django.utils import timezone
from django.utils.html import strip_tags

from catalog_app.models import Book, Newsletter, NewsletterBlock, Subscriber
from store.email_utils import BRAND, FONT_STACK, render_email_shell
from system_logs.models import SystemLog
from system_logs.services import log_event

logger = logging.getLogger(__name__)

_ALLOWED_TAGS = ["b", "i", "strong", "em", "a", "p", "br", "ul", "ol", "li"]
_ALLOWED_ATTRS = {"a": ["href", "target", "rel"]}
_ALLOWED_PROTOCOLS = ["http", "https", "mailto"]


def sanitize_block_html(raw_html: str) -> str:
    """Allowlist-sanitize rich-text block content — strips scripts, unsafe tags/protocols."""
    if not raw_html:
        return ""
    return bleach.clean(
        raw_html, tags=_ALLOWED_TAGS, attributes=_ALLOWED_ATTRS,
        protocols=_ALLOWED_PROTOCOLS, strip=True,
    )


# ---------------------------------------------------------------------------
# Block library (composer metadata + render templates)
# ---------------------------------------------------------------------------

_BLOCK_TEMPLATES = {
    NewsletterBlock.TYPE_HERO_IMAGE: "catalog_app/email/newsletter_blocks/hero_image.html",
    NewsletterBlock.TYPE_HEADING: "catalog_app/email/newsletter_blocks/heading.html",
    NewsletterBlock.TYPE_RICH_TEXT: "catalog_app/email/newsletter_blocks/rich_text.html",
    NewsletterBlock.TYPE_IMAGE_TEXT: "catalog_app/email/newsletter_blocks/image_text.html",
    NewsletterBlock.TYPE_BUTTON: "catalog_app/email/newsletter_blocks/button.html",
    NewsletterBlock.TYPE_DIVIDER: "catalog_app/email/newsletter_blocks/divider.html",
    NewsletterBlock.TYPE_SPACER: "catalog_app/email/newsletter_blocks/spacer.html",
    NewsletterBlock.TYPE_BOOK: "catalog_app/email/newsletter_blocks/book_highlight.html",
    NewsletterBlock.TYPE_FOOTER: "catalog_app/email/newsletter_blocks/footer_links.html",
}

# Human-facing metadata for the composer's block library (left panel).
BLOCK_REGISTRY = {
    NewsletterBlock.TYPE_HERO_IMAGE: {
        "label": "Hero Image", "group": "Media", "icon": "🖼",
        "description": "A wide opening image with an optional headline.",
        "default_config": {"image_url": "", "alt_text": "", "headline": "", "subtext": "", "link_url": ""},
    },
    NewsletterBlock.TYPE_HEADING: {
        "label": "Heading", "group": "Content", "icon": "🔠",
        "description": "A section title.",
        "default_config": {"text": "", "align": "left", "color": "text"},
    },
    NewsletterBlock.TYPE_RICH_TEXT: {
        "label": "Rich Text", "group": "Content", "icon": "📝",
        "description": "A paragraph with bold/italic/links/lists.",
        "default_config": {"html": ""},
    },
    NewsletterBlock.TYPE_IMAGE_TEXT: {
        "label": "Image + Text", "group": "Media", "icon": "🖇",
        "description": "An image beside a heading and description.",
        "default_config": {
            "image_url": "", "alt_text": "", "heading": "", "html": "",
            "link_url": "", "image_position": "left",
        },
    },
    NewsletterBlock.TYPE_BUTTON: {
        "label": "Button / CTA", "group": "Layout", "icon": "🔘",
        "description": "A call-to-action button.",
        "default_config": {"label": "", "url": "", "color": "gold", "align": "center"},
    },
    NewsletterBlock.TYPE_DIVIDER: {
        "label": "Divider", "group": "Layout", "icon": "➖",
        "description": "A horizontal rule to separate sections.",
        "default_config": {"color": "border"},
    },
    NewsletterBlock.TYPE_SPACER: {
        "label": "Spacer", "group": "Layout", "icon": "↕",
        "description": "Vertical breathing room.",
        "default_config": {"height": 24},
    },
    NewsletterBlock.TYPE_BOOK: {
        "label": "Book Highlight", "group": "Commerce", "icon": "📚",
        "description": "Feature a book from the catalog with a Shop Now button.",
        "default_config": {
            "book_id": None, "badge": "", "button_label": "Shop Now", "description": "",
            "title_override": "", "price_override": "", "url_override": "",
        },
    },
    NewsletterBlock.TYPE_FOOTER: {
        "label": "Footer Links", "group": "Layout", "icon": "🔗",
        "description": "Social/contact links and the unsubscribe line. Required before sending.",
        "default_config": {},
    },
}

SPACER_HEIGHT_CHOICES = [8, 16, 24, 32, 48, 64]
BUTTON_COLOR_CHOICES = ["gold", "green", "rust"]

_UNSUBSCRIBE_PLACEHOLDER = "#"


def absolute_media_url(url: str) -> str:
    """
    Media URLs (e.g. ImageField.url) are relative — useless in an email,
    which has no "page" to resolve them against. Always anchored to the
    real backend domain (SITE_URL), deliberately NOT request.build_absolute_uri()
    — a staff member composing/testing from http://localhost:8008 must not
    produce a localhost URL baked into an email that goes out to real
    recipients (nothing outside that one machine could ever load it).
    """
    if not url or url.startswith(("http://", "https://")):
        return url
    return f"{settings.SITE_URL.rstrip('/')}{url}"


def _book_highlight_context(config: dict) -> dict:
    """Resolve a book_highlight block against the real Book catalog, degrading gracefully if data's missing."""
    book = None
    book_id = config.get("book_id")
    if book_id:
        book = Book.objects.filter(pk=book_id).select_related("author").first()

    cover_url = ""
    if book and book.cover:
        try:
            cover_url = absolute_media_url(book.cover.url)
        except ValueError:
            cover_url = ""

    price = config.get("price_override") or (
        str(book.selling_price_kes or book.price)
        if book and (book.selling_price_kes or book.price) else ""
    )
    purchase_url = config.get("url_override") or (
        f"{settings.PUBLIC_STORE_URL.rstrip('/')}/books/{book.slug}/"
        if book and getattr(book, "slug", "") else ""
    )

    return {
        "title": config.get("title_override") or (book.title if book else ""),
        "cover_url": cover_url,
        "author_name": book.author.name if book and book.author else "",
        "price": price,
        "purchase_url": purchase_url,
        "badge": config.get("badge", ""),
        "button_label": config.get("button_label") or "Shop Now",
        "description": config.get("description", ""),
    }


def render_block(block: NewsletterBlock) -> str:
    """Render one block's HTML fragment. Never raises — a broken block renders empty rather than killing the whole newsletter."""
    template = _BLOCK_TEMPLATES.get(block.block_type)
    if not template:
        return ""
    config = block.config or {}
    try:
        if block.block_type == NewsletterBlock.TYPE_RICH_TEXT:
            context = {"html": sanitize_block_html(config.get("html", ""))}
        elif block.block_type == NewsletterBlock.TYPE_IMAGE_TEXT:
            context = {**config, "html": sanitize_block_html(config.get("html", ""))}
        elif block.block_type == NewsletterBlock.TYPE_BOOK:
            context = _book_highlight_context(config)
        elif block.block_type == NewsletterBlock.TYPE_SPACER:
            context = {"height": config.get("height") or 24}
        else:
            context = dict(config)
        context["brand"] = BRAND
        context["font_stack"] = FONT_STACK
        return render_to_string(template, context)
    except Exception:
        logger.exception("Failed to render newsletter block %s (type=%s)", block.pk, block.block_type)
        return ""


# ---------------------------------------------------------------------------
# Newsletter rendering (preview / test / real send all go through this)
# ---------------------------------------------------------------------------

def _unsubscribe_url(subscriber) -> str:
    if subscriber is None:
        return _UNSUBSCRIBE_PLACEHOLDER
    base = getattr(settings, "SITE_URL", "").rstrip("/")
    return f"{base}/api/newsletter/unsubscribe/{subscriber.token}/"


def render_newsletter_html(newsletter: Newsletter, *, subscriber=None) -> str:
    """The exact HTML used by preview, test-send, and the real send — subscriber=None renders a safe preview."""
    body_parts = []
    for block in newsletter.blocks.all():
        if block.block_type == NewsletterBlock.TYPE_FOOTER:
            body_parts.append(render_to_string(_BLOCK_TEMPLATES[NewsletterBlock.TYPE_FOOTER], {
                "unsubscribe_url": _unsubscribe_url(subscriber),
                "brand": BRAND,
                "font_stack": FONT_STACK,
            }))
        else:
            body_parts.append(render_block(block))
    body_html = "\n".join(body_parts)
    return render_email_shell(
        heading=newsletter.subject,
        body_html=body_html,
        brand=newsletter.brand,
        preheader=newsletter.preheader,
    )


def _html_to_text(html: str) -> str:
    """strip_tags-based plain-text fallback, with entities decoded and the
    blank-line debris a table-based layout leaves behind collapsed away."""
    raw = html_module.unescape(strip_tags(html))
    lines = [line.strip() for line in raw.splitlines()]
    return "\n\n".join(line for line in lines if line)


def render_newsletter_text(newsletter: Newsletter) -> str:
    """Plain-text alternative — consistent with the rest of this codebase's emails."""
    return _html_to_text(render_newsletter_html(newsletter, subscriber=None))


# ---------------------------------------------------------------------------
# Welcome email
# ---------------------------------------------------------------------------

def send_welcome_email(subscriber: Subscriber) -> bool:
    """Sent once, right when someone subscribes (new signup or reactivation)."""
    body_html = (
        "<p>Thanks for subscribing to the Tai AfroPress newsletter!</p>"
        "<p>You'll hear from us soon with our next edition — new releases, author "
        "features, and news from across Tai AfroPress and Tai BookStore.</p>"
    )
    html = render_email_shell(heading="Welcome to Tai AfroPress", body_html=body_html, brand="afropress")
    try:
        email = EmailMultiAlternatives(
            subject="Welcome to the Tai AfroPress newsletter",
            body=_html_to_text(html),
            from_email=settings.DEFAULT_FROM_EMAIL,
            to=[subscriber.email],
        )
        email.attach_alternative(html, "text/html")
        email.send()
        return True
    except Exception as exc:
        log_event(
            SystemLog.MODULE_CATALOG, "newsletter.welcome.failed",
            f"Failed to send welcome email to {subscriber.email}",
            level=SystemLog.LEVEL_ERROR, reference=f"subscriber:{subscriber.pk}",
            related=subscriber, exc=exc,
        )
        return False


# ---------------------------------------------------------------------------
# Test send
# ---------------------------------------------------------------------------

def send_test_email(newsletter: Newsletter, to_email: str) -> bool:
    html = render_newsletter_html(newsletter, subscriber=None)
    text = render_newsletter_text(newsletter)
    try:
        email = EmailMultiAlternatives(
            subject=f"[TEST] {newsletter.subject}",
            body=text,
            from_email=settings.DEFAULT_FROM_EMAIL,
            to=[to_email],
        )
        email.attach_alternative(html, "text/html")
        email.send()
        return True
    except Exception as exc:
        log_event(
            SystemLog.MODULE_CATALOG, "newsletter.test_send.failed",
            f"Failed to send test email for '{newsletter.subject}' to {to_email}",
            level=SystemLog.LEVEL_ERROR, reference=f"newsletter:{newsletter.pk}",
            related=newsletter, exc=exc,
        )
        return False


# ---------------------------------------------------------------------------
# Bulk send — chunked, resumable, single reused SMTP connection
# ---------------------------------------------------------------------------

def send_newsletter_chunked(newsletter: Newsletter, *, chunk_size: int | None = None, pause_seconds: float | None = None) -> None:
    """
    Sends to every active Subscriber with id > newsletter.send_cursor_subscriber_id,
    in chunks, over one reused SMTP connection. Safe to call again after an
    interruption (worker recycle, timeout) — it resumes from the persisted
    cursor rather than restarting or re-sending already-delivered recipients.
    """
    chunk_size = chunk_size or settings.NEWSLETTER_SEND_CHUNK_SIZE
    pause_seconds = settings.NEWSLETTER_SEND_PAUSE_SECONDS if pause_seconds is None else pause_seconds

    if newsletter.status == Newsletter.STATUS_DRAFT:
        newsletter.status = Newsletter.STATUS_SENDING
        newsletter.send_started_at = timezone.now()
        newsletter.total_recipients = Subscriber.objects.filter(is_active=True).count()
        newsletter.save(update_fields=["status", "send_started_at", "total_recipients"])
    elif newsletter.status != Newsletter.STATUS_SENDING:
        raise ValueError(f"Newsletter is not sendable from status '{newsletter.status}'.")

    text = render_newsletter_text(newsletter)

    connection = get_connection()
    connection.open()
    try:
        while True:
            cursor = newsletter.send_cursor_subscriber_id or 0
            batch = list(
                Subscriber.objects.filter(is_active=True, id__gt=cursor).order_by("id")[:chunk_size]
            )
            if not batch:
                break
            for subscriber in batch:
                try:
                    html = render_newsletter_html(newsletter, subscriber=subscriber)
                    email = EmailMultiAlternatives(
                        subject=newsletter.subject, body=text,
                        from_email=settings.DEFAULT_FROM_EMAIL, to=[subscriber.email],
                        connection=connection,
                    )
                    email.attach_alternative(html, "text/html")
                    email.send()
                    newsletter.sent_count += 1
                except Exception as exc:
                    newsletter.failed_count += 1
                    log_event(
                        SystemLog.MODULE_CATALOG, "newsletter.send.failed",
                        f"Failed to send '{newsletter.subject}' to {subscriber.email}",
                        level=SystemLog.LEVEL_ERROR, reference=f"newsletter:{newsletter.pk}",
                        related=newsletter, exc=exc,
                    )
                newsletter.send_cursor_subscriber_id = subscriber.pk
            newsletter.save(update_fields=["sent_count", "failed_count", "send_cursor_subscriber_id"])
            time.sleep(pause_seconds)
    except Exception as exc:
        log_event(
            SystemLog.MODULE_CATALOG, "newsletter.send.connection_failed",
            f"Newsletter send run-level failure for '{newsletter.subject}'",
            level=SystemLog.LEVEL_ERROR, reference=f"newsletter:{newsletter.pk}",
            related=newsletter, exc=exc, alert=True,
        )
        raise
    finally:
        connection.close()

    newsletter.status = Newsletter.STATUS_SENT
    newsletter.sent_at = timezone.now()
    newsletter.save(update_fields=["status", "sent_at"])
