"""
catalog_app/admin_newsletter.py
──────────────────────────────────
Custom admin UI for the Newsletter composer. Follows the Reports-Hub
convention (inventory/admin_reports.py): everything beyond the vanilla
changelist lives behind ModelAdmin.get_urls() custom routes, wrapped in
self.admin_site.admin_view(...).
"""

import json
import logging

from ckeditor.widgets import CKEditorWidget
from django import forms
from django.contrib import admin, messages
from django.http import HttpResponse, JsonResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.urls import path, reverse
from django.utils.html import format_html
from django.views.decorators.clickjacking import xframe_options_sameorigin

from catalog_app.models import Book, Newsletter, NewsletterBlock, NewsletterImage
from catalog_app.services.newsletter_service import (
    BLOCK_REGISTRY,
    BUTTON_COLOR_CHOICES,
    SPACER_HEIGHT_CHOICES,
    absolute_media_url,
    render_newsletter_html,
    send_newsletter_chunked,
    send_test_email,
)

logger = logging.getLogger(__name__)


# ---------------------------------------------------------------------------
# Per-block-type forms — one per NewsletterBlock.block_type, used for both
# adding and editing a block. Config stored on NewsletterBlock.config is
# exactly these forms' cleaned_data (with "book" swapped for "book_id").
# ---------------------------------------------------------------------------

class HeroImageBlockForm(forms.Form):
    image_url = forms.URLField(required=False, label="Image URL")
    alt_text = forms.CharField(required=False, max_length=255, label="Alt text")
    headline = forms.CharField(required=False, max_length=255)
    subtext = forms.CharField(required=False, max_length=255)
    link_url = forms.URLField(required=False, label="Link (optional)")


class HeadingBlockForm(forms.Form):
    text = forms.CharField(max_length=255)
    align = forms.ChoiceField(choices=[("left", "Left"), ("center", "Center"), ("right", "Right")], initial="left")
    color = forms.ChoiceField(choices=[("text", "Default"), ("rust", "Rust"), ("green", "Green")], initial="text")


class RichTextBlockForm(forms.Form):
    html = forms.CharField(
        required=False, label="Text",
        widget=CKEditorWidget(config_name="newsletter_richtext"),
    )


class ImageTextBlockForm(forms.Form):
    image_url = forms.URLField(required=False, label="Image URL")
    alt_text = forms.CharField(required=False, max_length=255, label="Alt text")
    heading = forms.CharField(required=False, max_length=255)
    html = forms.CharField(required=False, label="Text", widget=CKEditorWidget(config_name="newsletter_richtext"))
    link_url = forms.URLField(required=False, label="Link (optional)")
    image_position = forms.ChoiceField(choices=[("left", "Image on the left"), ("right", "Image on the right")], initial="left")


class ButtonBlockForm(forms.Form):
    label = forms.CharField(max_length=60)
    url = forms.URLField()
    color = forms.ChoiceField(choices=[(c, c.title()) for c in BUTTON_COLOR_CHOICES], initial="gold")
    align = forms.ChoiceField(choices=[("left", "Left"), ("center", "Center"), ("right", "Right")], initial="center")


class DividerBlockForm(forms.Form):
    color = forms.ChoiceField(choices=[("border", "Subtle"), ("gold", "Gold"), ("rust", "Rust")], initial="border")


class SpacerBlockForm(forms.Form):
    height = forms.TypedChoiceField(
        choices=[(h, f"{h}px") for h in SPACER_HEIGHT_CHOICES], coerce=int, initial=24,
    )


class BookHighlightBlockForm(forms.Form):
    book = forms.ModelChoiceField(
        queryset=Book.objects.filter(is_listed=True).order_by("title"),
        required=False, label="Book (from catalog)",
        help_text="Title, cover, author and price auto-fill from this book. Leave blank to fill in manually below.",
    )
    badge = forms.CharField(required=False, max_length=40, help_text='e.g. "New Release" or "Featured"')
    button_label = forms.CharField(required=False, max_length=40, initial="Shop Now")
    description = forms.CharField(required=False, max_length=300, widget=forms.Textarea(attrs={"rows": 2}))
    title_override = forms.CharField(required=False, max_length=255, label="Title override")
    price_override = forms.CharField(required=False, max_length=30, label="Price override (KES)")
    url_override = forms.URLField(required=False, label="Purchase link override")


class FooterBlockForm(forms.Form):
    """No configurable fields — unsubscribe link and brand footer text are generated automatically."""


BLOCK_FORMS = {
    NewsletterBlock.TYPE_HERO_IMAGE: HeroImageBlockForm,
    NewsletterBlock.TYPE_HEADING: HeadingBlockForm,
    NewsletterBlock.TYPE_RICH_TEXT: RichTextBlockForm,
    NewsletterBlock.TYPE_IMAGE_TEXT: ImageTextBlockForm,
    NewsletterBlock.TYPE_BUTTON: ButtonBlockForm,
    NewsletterBlock.TYPE_DIVIDER: DividerBlockForm,
    NewsletterBlock.TYPE_SPACER: SpacerBlockForm,
    NewsletterBlock.TYPE_BOOK: BookHighlightBlockForm,
    NewsletterBlock.TYPE_FOOTER: FooterBlockForm,
}


def _form_to_config(block_type, cleaned_data):
    data = dict(cleaned_data)
    if block_type == NewsletterBlock.TYPE_BOOK:
        book = data.pop("book", None)
        data["book_id"] = book.pk if book else None
    return data


def _config_to_initial(block):
    initial = dict(block.config or {})
    if block.block_type == NewsletterBlock.TYPE_BOOK and initial.get("book_id"):
        initial["book"] = initial["book_id"]
    return initial


# ---------------------------------------------------------------------------
# Admin
# ---------------------------------------------------------------------------

@admin.register(Newsletter)
class NewsletterAdmin(admin.ModelAdmin):
    change_list_template = "admin/catalog_app/newsletter/change_list.html"
    list_display = ["subject", "brand", "status_badge", "total_recipients", "sent_count", "failed_count", "created_at", "sent_at"]
    list_filter = ["status", "brand", "is_template"]
    search_fields = ["subject"]
    readonly_fields = [
        "status", "total_recipients", "sent_count", "failed_count",
        "send_cursor_subscriber_id", "send_started_at", "sent_at", "created_at",
    ]

    @admin.display(description="Status")
    def status_badge(self, obj):
        colors = {
            Newsletter.STATUS_DRAFT: "#6d6152",
            Newsletter.STATUS_SENDING: "#e8932c",
            Newsletter.STATUS_SENT: "#1f5039",
            Newsletter.STATUS_FAILED: "#b9461f",
        }
        return format_html(
            '<span style="color:{}; font-weight:bold;">{}</span>',
            colors.get(obj.status, "#333"), obj.get_status_display(),
        )

    def has_add_permission(self, request):
        return False  # use the "+ New Newsletter" compose flow instead

    def get_queryset(self, request):
        # Templates are only surfaced via the "Start from a template…" picker
        # on the changelist, not mixed in with real draft/sent newsletters.
        return super().get_queryset(request).exclude(is_template=True)

    def changelist_view(self, request, extra_context=None):
        extra_context = dict(extra_context or {})
        extra_context["newsletter_templates"] = Newsletter.objects.filter(is_template=True).order_by("subject")
        return super().changelist_view(request, extra_context)

    def change_view(self, request, object_id, form_url="", extra_context=None):
        return redirect("admin:catalog_app_newsletter_compose", pk=object_id)

    # ------------------------------------------------------------------
    # URLs
    # ------------------------------------------------------------------

    def get_urls(self):
        custom = [
            path("new/", self.admin_site.admin_view(self.new_view), name="catalog_app_newsletter_new"),
            path("<int:pk>/compose/", self.admin_site.admin_view(self.compose_view), name="catalog_app_newsletter_compose"),
            path("<int:pk>/block/add/", self.admin_site.admin_view(self.add_block_view), name="catalog_app_newsletter_block_add"),
            path("block/<int:block_id>/update/", self.admin_site.admin_view(self.update_block_view), name="catalog_app_newsletter_block_update"),
            path("block/<int:block_id>/delete/", self.admin_site.admin_view(self.delete_block_view), name="catalog_app_newsletter_block_delete"),
            path("reorder/", self.admin_site.admin_view(self.reorder_blocks_view), name="catalog_app_newsletter_reorder"),
            path("<int:pk>/preview/", self.admin_site.admin_view(self.preview_view), name="catalog_app_newsletter_preview"),
            path("<int:pk>/send-test/", self.admin_site.admin_view(self.send_test_view), name="catalog_app_newsletter_send_test"),
            path("<int:pk>/send/", self.admin_site.admin_view(self.send_view), name="catalog_app_newsletter_send"),
            path("<int:pk>/send-progress/", self.admin_site.admin_view(self.send_progress_view), name="catalog_app_newsletter_send_progress"),
            path("<int:pk>/resume/", self.admin_site.admin_view(self.resume_view), name="catalog_app_newsletter_resume"),
            path("templates/<int:template_id>/use/", self.admin_site.admin_view(self.from_template_view), name="catalog_app_newsletter_from_template"),
            path("block/upload-image/", self.admin_site.admin_view(self.upload_image_view), name="catalog_app_newsletter_upload_image"),
        ]
        return custom + super().get_urls()

    # ------------------------------------------------------------------
    # Compose
    # ------------------------------------------------------------------

    def new_view(self, request):
        newsletter = Newsletter.objects.create(subject="Untitled Newsletter")
        return redirect("admin:catalog_app_newsletter_compose", pk=newsletter.pk)

    def compose_view(self, request, pk):
        newsletter = get_object_or_404(Newsletter, pk=pk)

        if request.method == "POST" and request.POST.get("action") == "save_meta":
            newsletter.subject = request.POST.get("subject", newsletter.subject).strip() or newsletter.subject
            newsletter.preheader = request.POST.get("preheader", "").strip()
            newsletter.brand = request.POST.get("brand", newsletter.brand)
            newsletter.save(update_fields=["subject", "preheader", "brand"])
            messages.success(request, "Saved.")
            return redirect("admin:catalog_app_newsletter_compose", pk=pk)

        blocks = []
        for block in newsletter.blocks.all():
            form_class = BLOCK_FORMS.get(block.block_type)
            form = form_class(initial=_config_to_initial(block)) if form_class else None
            blocks.append({"obj": block, "form": form, "meta": BLOCK_REGISTRY.get(block.block_type, {})})

        add_type = request.GET.get("add")
        add_form = BLOCK_FORMS[add_type]() if add_type in BLOCK_FORMS else None
        add_meta = BLOCK_REGISTRY.get(add_type, {})

        has_footer = newsletter.blocks.filter(block_type=NewsletterBlock.TYPE_FOOTER).exists()
        has_content = newsletter.blocks.exclude(block_type=NewsletterBlock.TYPE_FOOTER).exists()

        # Always load CKEditor's JS/CSS regardless of which block types are
        # currently on the page — "Rich Text" / "Image + Text" can be added
        # at any time via the library, and their editor needs this to render
        # as anything more than a plain <textarea>.
        media = RichTextBlockForm().media + ImageTextBlockForm().media

        return render(request, "admin/catalog_app/newsletter/compose.html", {
            **self.admin_site.each_context(request),
            "title": f"Compose — {newsletter.subject}",
            "opts": self.model._meta,
            "media": media,
            "newsletter": newsletter,
            "blocks": blocks,
            "block_registry": BLOCK_REGISTRY,
            "block_groups": sorted({meta["group"] for meta in BLOCK_REGISTRY.values()}),
            "brand_choices": Newsletter.BRAND_CHOICES,
            "add_type": add_type,
            "add_form": add_form,
            "add_meta": add_meta,
            "ready_to_send": has_footer and has_content and newsletter.status == Newsletter.STATUS_DRAFT,
        })

    def add_block_view(self, request, pk):
        newsletter = get_object_or_404(Newsletter, pk=pk)
        if request.method != "POST":
            return redirect("admin:catalog_app_newsletter_compose", pk=pk)
        block_type = request.POST.get("block_type")
        form_class = BLOCK_FORMS.get(block_type)
        if not form_class:
            messages.error(request, "Unknown block type.")
            return redirect("admin:catalog_app_newsletter_compose", pk=pk)
        form = form_class(request.POST)
        if not form.is_valid():
            messages.error(request, "Could not add block — check the fields below.")
            return redirect(f"{reverse('admin:catalog_app_newsletter_compose', args=[pk])}?add={block_type}")
        next_position = newsletter.blocks.count() + 1
        NewsletterBlock.objects.create(
            newsletter=newsletter, block_type=block_type, position=next_position,
            config=_form_to_config(block_type, form.cleaned_data),
        )
        messages.success(request, f"{BLOCK_REGISTRY.get(block_type, {}).get('label', 'Block')} added.")
        return redirect("admin:catalog_app_newsletter_compose", pk=pk)

    def update_block_view(self, request, block_id):
        block = get_object_or_404(NewsletterBlock, pk=block_id)
        pk = block.newsletter_id
        if request.method != "POST":
            return redirect("admin:catalog_app_newsletter_compose", pk=pk)
        form_class = BLOCK_FORMS.get(block.block_type)
        if form_class:
            form = form_class(request.POST)
            if not form.is_valid():
                messages.error(request, "Could not save that block — check the fields.")
                return redirect("admin:catalog_app_newsletter_compose", pk=pk)
            block.config = _form_to_config(block.block_type, form.cleaned_data)
            block.save(update_fields=["config", "updated_at"])
        messages.success(request, "Block updated.")
        return redirect("admin:catalog_app_newsletter_compose", pk=pk)

    def delete_block_view(self, request, block_id):
        block = get_object_or_404(NewsletterBlock, pk=block_id)
        pk = block.newsletter_id
        if request.method == "POST":
            block.delete()
            messages.success(request, "Block removed.")
        return redirect("admin:catalog_app_newsletter_compose", pk=pk)

    def reorder_blocks_view(self, request):
        if request.method != "POST":
            return JsonResponse({"error": "POST required"}, status=405)
        try:
            order = json.loads(request.body).get("order", [])
        except (ValueError, TypeError):
            return JsonResponse({"error": "bad payload"}, status=400)
        for index, block_id in enumerate(order, start=1):
            NewsletterBlock.objects.filter(pk=block_id).update(position=index)
        return JsonResponse({"ok": True})

    # ------------------------------------------------------------------
    # Preview / test / send
    # ------------------------------------------------------------------

    @xframe_options_sameorigin
    def preview_view(self, request, pk):
        # Django's default X-Frame-Options is DENY (clickjacking protection)
        # — this view is deliberately loaded in an iframe by the composer
        # page, so it needs same-origin framing allowed. Every other view
        # keeps the site-wide default.
        newsletter = get_object_or_404(Newsletter, pk=pk)
        return HttpResponse(render_newsletter_html(newsletter, subscriber=None))

    def send_test_view(self, request, pk):
        newsletter = get_object_or_404(Newsletter, pk=pk)
        if request.method != "POST":
            return redirect("admin:catalog_app_newsletter_compose", pk=pk)
        to_email = (request.POST.get("to_email") or "").strip() or request.user.email
        if not to_email:
            messages.error(request, "No email address to send the test to.")
            return redirect("admin:catalog_app_newsletter_compose", pk=pk)
        if send_test_email(newsletter, to_email):
            messages.success(request, f"Test email sent to {to_email}.")
        else:
            messages.error(request, "Failed to send the test email — check the System Log for details.")
        return redirect("admin:catalog_app_newsletter_compose", pk=pk)

    def send_view(self, request, pk):
        newsletter = get_object_or_404(Newsletter, pk=pk)
        if request.method != "POST":
            return redirect("admin:catalog_app_newsletter_compose", pk=pk)
        if newsletter.status != Newsletter.STATUS_DRAFT:
            messages.error(request, "This newsletter has already been sent or is currently sending.")
            return redirect("admin:catalog_app_newsletter_compose", pk=pk)
        if not newsletter.blocks.filter(block_type=NewsletterBlock.TYPE_FOOTER).exists():
            messages.error(request, "Add a Footer Links block (it carries the unsubscribe link) before sending.")
            return redirect("admin:catalog_app_newsletter_compose", pk=pk)
        if not newsletter.blocks.exclude(block_type=NewsletterBlock.TYPE_FOOTER).exists():
            messages.error(request, "Add at least one content block before sending.")
            return redirect("admin:catalog_app_newsletter_compose", pk=pk)
        try:
            send_newsletter_chunked(newsletter)
        except Exception:
            logger.exception("Newsletter %s send failed", newsletter.pk)
            messages.error(request, "Send failed partway through — check the System Log, then use Resume to continue.")
        else:
            messages.success(request, f"Sent — {newsletter.sent_count} delivered, {newsletter.failed_count} failed.")
        return redirect("admin:catalog_app_newsletter_compose", pk=pk)

    def send_progress_view(self, request, pk):
        newsletter = get_object_or_404(Newsletter, pk=pk)
        return JsonResponse({
            "status": newsletter.status,
            "sent_count": newsletter.sent_count,
            "failed_count": newsletter.failed_count,
            "total_recipients": newsletter.total_recipients,
        })

    def resume_view(self, request, pk):
        newsletter = get_object_or_404(Newsletter, pk=pk)
        if request.method != "POST":
            return redirect("admin:catalog_app_newsletter_compose", pk=pk)
        if newsletter.status != Newsletter.STATUS_SENDING:
            messages.error(request, "Nothing to resume.")
            return redirect("admin:catalog_app_newsletter_compose", pk=pk)
        try:
            send_newsletter_chunked(newsletter)
        except Exception:
            logger.exception("Newsletter %s resume failed", newsletter.pk)
            messages.error(request, "Resume failed partway through — check the System Log.")
        else:
            messages.success(request, f"Resumed and completed — {newsletter.sent_count} sent, {newsletter.failed_count} failed.")
        return redirect("admin:catalog_app_newsletter_compose", pk=pk)

    def from_template_view(self, request, template_id):
        template = get_object_or_404(Newsletter, pk=template_id, is_template=True)
        newsletter = Newsletter.objects.create(
            subject=f"{template.subject} (copy)", preheader=template.preheader, brand=template.brand,
        )
        for block in template.blocks.all():
            NewsletterBlock.objects.create(
                newsletter=newsletter, block_type=block.block_type,
                position=block.position, config=block.config,
            )
        return redirect("admin:catalog_app_newsletter_compose", pk=newsletter.pk)

    # ------------------------------------------------------------------
    # Image upload (used by the block editor's upload-and-crop tool)
    # ------------------------------------------------------------------

    MAX_UPLOAD_BYTES = 8 * 1024 * 1024  # 8MB — the browser already cropped/compressed it

    def upload_image_view(self, request):
        if request.method != "POST":
            return JsonResponse({"error": "POST required"}, status=405)
        upload = request.FILES.get("image")
        if not upload:
            return JsonResponse({"error": "No image provided."}, status=400)
        if not (upload.content_type or "").startswith("image/"):
            return JsonResponse({"error": "File is not an image."}, status=400)
        if upload.size > self.MAX_UPLOAD_BYTES:
            return JsonResponse({"error": "Image is too large (max 8MB)."}, status=400)
        record = NewsletterImage.objects.create(image=upload)
        # absolute_media_url(), not request.build_absolute_uri() — this must
        # stay reachable for real recipients even when a staff member is
        # composing/testing from http://localhost:8008.
        return JsonResponse({"url": absolute_media_url(record.image.url)})


@admin.register(NewsletterImage)
class NewsletterImageAdmin(admin.ModelAdmin):
    """Read-only-ish gallery of images uploaded via the composer's upload-and-crop tool — for visibility/cleanup."""
    list_display = ["thumbnail", "image", "uploaded_at"]
    readonly_fields = ["thumbnail", "image", "uploaded_at"]
    ordering = ["-uploaded_at"]

    def has_add_permission(self, request):
        return False

    def has_change_permission(self, request, obj=None):
        return False

    @admin.display(description="Preview")
    def thumbnail(self, obj):
        if not obj.image:
            return "—"
        return format_html('<img src="{}" style="max-height:50px;max-width:80px;border-radius:4px;">', obj.image.url)
