pkmntrade.club/trades/views.py

from django.views.generic import TemplateView, DeleteView, CreateView, ListView, DetailView, UpdateView, FormView
from django.views import View
from django.urls import reverse_lazy
from django.http import HttpResponseRedirect, JsonResponse
from django.contrib.auth.mixins import LoginRequiredMixin
from django.shortcuts import get_object_or_404, render
from django.core.exceptions import PermissionDenied, ValidationError
from django.views.generic.edit import FormMixin
from django.utils import timezone
from django.db.models import Q, Case, When, Value, BooleanField, Prefetch, F
from django.utils.decorators import method_decorator
from django.views.decorators.http import require_http_methods
from django.core.paginator import Paginator
from django.contrib import messages
from django.views.decorators.cache import cache_page
from meta.views import Meta
from .models import TradeOffer, TradeAcceptance
from .forms import (TradeOfferAcceptForm,
                    TradeAcceptanceCreateForm, TradeOfferCreateForm, TradeAcceptanceTransitionForm)
from cards.models import Card
import imgkit
from django.http import HttpResponse, Http404
from django.template.loader import render_to_string
from trades.templatetags.trade_offer_tags import render_trade_offer
from django.template import RequestContext
from playwright.sync_api import sync_playwright
from django.conf import settings

class TradeOfferCreateView(LoginRequiredMixin, CreateView):
    http_method_names = ['get']  # restricts this view to GET only
    model = TradeOffer
    form_class = TradeOfferCreateForm
    template_name = "trades/trade_offer_create.html"
    success_url = reverse_lazy("trade_offer_list")

    def get_form(self, form_class=None):
        form = super().get_form(form_class)
        # Restrict the 'initiated_by' choices to friend codes owned by the logged-in user.
        form.fields["initiated_by"].queryset = self.request.user.friend_codes.all()
        return form

    def get_initial(self):
        initial = super().get_initial()
        initial["have_cards"] = self.request.GET.getlist("have_cards")
        initial["want_cards"] = self.request.GET.getlist("want_cards")
        if self.request.user.friend_codes.count() == 1:
            initial["initiated_by"] = self.request.user.friend_codes.first().pk
        return initial

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        from cards.models import Card
        # Ensure available_cards is a proper QuerySet
        context["cards"] = Card.objects.all().order_by("name", "rarity_level")
        friend_codes = self.request.user.friend_codes.all()
        if "initiated_by" in self.request.GET:
            try:
                selected_friend_code = friend_codes.get(pk=self.request.GET.get("initiated_by"))
            except friend_codes.model.DoesNotExist:
                selected_friend_code = self.request.user.default_friend_code or friend_codes.first()
        else:
            selected_friend_code = self.request.user.default_friend_code or friend_codes.first()
        context["friend_codes"] = friend_codes
        context["selected_friend_code"] = selected_friend_code
        return context

class TradeOfferAllListView(ListView):
    model = TradeOffer
    template_name = "trades/trade_offer_all_list.html"

    #@silk_profile(name="Trade Offer All List- Get Context Data")
    def get_context_data(self, *, object_list=None, **kwargs):
        context = super().get_context_data(**kwargs)
        request = self.request
        show_closed = request.GET.get("show_closed", "false").lower() == "true"
        context["show_closed"] = show_closed

        # Build the queryset with our related objects.
        queryset = TradeOffer.objects
        if show_closed:
            queryset = queryset.filter(is_closed=True)
        else:
            queryset = queryset.filter(is_closed=False)

        # On initial load, use the 'offers_page' parameter.
        offers_page = request.GET.get("offers_page")
        offers_paginator = Paginator(queryset, 10)
        context["all_trade_offers_paginated"] = offers_paginator.get_page(offers_page)
        return context

    #@silk_profile(name="Trade Offer All List- Render to Response")
    def render_to_response(self, context, **response_kwargs):
        # For AJAX requests, return only the paginated fragment.
        if self.request.headers.get("X-Requested-With") == "XMLHttpRequest":
            page = self.request.GET.get("page")
            show_closed = self.request.GET.get("show_closed", "false").lower() == "true"

            queryset = TradeOffer.objects
            if show_closed:
                queryset = queryset.filter(is_closed=True)
            else:
                queryset = queryset.filter(is_closed=False)
            paginated_offers = Paginator(queryset, 10).get_page(page)
            return render(
                self.request,
                "trades/_trade_offer_list_paginated.html",
                {"offers": paginated_offers}
            )
        return super().render_to_response(context, **response_kwargs)

class TradeOfferMyListView(LoginRequiredMixin, ListView):
    model = TradeOffer  # Fallback model; our context data holds separate filtered querysets.
    template_name = "trades/trade_offer_my_list.html"

    def dispatch(self, request, *args, **kwargs):
        if request.user.is_authenticated and not request.user.friend_codes.exists():
            raise PermissionDenied("No friend codes available for your account.")
        return super().dispatch(request, *args, **kwargs)

    def get_selected_friend_code(self):
        friend_codes = self.request.user.friend_codes.all()
        friend_code_param = self.request.GET.get("friend_code")
        if friend_code_param:
            try:
                selected_friend_code = friend_codes.get(pk=friend_code_param)
            except friend_codes.model.DoesNotExist:
                selected_friend_code = self.request.user.default_friend_code or friend_codes.first()
        else:
            selected_friend_code = self.request.user.default_friend_code or friend_codes.first()

        if not selected_friend_code:
            raise PermissionDenied("You do not have an active friend code associated with your account.")

        return selected_friend_code

    def get_show_closed(self):
        return self.request.GET.get("show_closed", "false").lower() == "true"

    def get_my_trade_offers_paginated(self, page_param):
        selected_friend_code = self.get_selected_friend_code()
        queryset = self.get_queryset().filter(initiated_by=selected_friend_code)
        if self.get_show_closed():
            queryset = queryset.filter(is_closed=True)
        else:
            queryset = queryset.filter(is_closed=False)
        return Paginator(queryset, 10).get_page(page_param)

    def get_involved_acceptances(self, selected_friend_code):
        terminal_states = [
            TradeAcceptance.AcceptanceState.THANKED_BY_INITIATOR,
            TradeAcceptance.AcceptanceState.THANKED_BY_ACCEPTOR,
            TradeAcceptance.AcceptanceState.THANKED_BY_BOTH,
            TradeAcceptance.AcceptanceState.REJECTED_BY_INITIATOR,
            TradeAcceptance.AcceptanceState.REJECTED_BY_ACCEPTOR,
        ]
        involved_acceptances_qs = TradeAcceptance.objects.filter(
            Q(trade_offer__initiated_by=selected_friend_code) | Q(accepted_by=selected_friend_code)
        ).order_by("-updated_at")
        if self.get_show_closed():
            return involved_acceptances_qs.filter(state__in=terminal_states)
        return involved_acceptances_qs.exclude(state__in=terminal_states)

    def get_trade_acceptances_waiting_paginated(self, page_param):
        selected_friend_code = self.get_selected_friend_code()
        involved_acceptances = self.get_involved_acceptances(selected_friend_code)
        waiting_acceptances = involved_acceptances.filter(
            Q(trade_offer__initiated_by=selected_friend_code, state__in=[
                TradeAcceptance.AcceptanceState.ACCEPTED,
                TradeAcceptance.AcceptanceState.RECEIVED,
            ]) |
            Q(accepted_by=selected_friend_code, state__in=[TradeAcceptance.AcceptanceState.SENT])
        )
        return Paginator(waiting_acceptances, 10).get_page(page_param)

    def get_other_party_trade_acceptances_paginated(self, page_param):
        selected_friend_code = self.get_selected_friend_code()
        involved_acceptances = self.get_involved_acceptances(selected_friend_code)
        waiting_acceptances = involved_acceptances.filter(
            Q(trade_offer__initiated_by=selected_friend_code, state__in=[
                TradeAcceptance.AcceptanceState.ACCEPTED,
                TradeAcceptance.AcceptanceState.RECEIVED,
            ]) |
            Q(accepted_by=selected_friend_code, state__in=[TradeAcceptance.AcceptanceState.SENT])
        )
        other_acceptances = involved_acceptances.exclude(pk__in=waiting_acceptances.values("pk"))
        return Paginator(other_acceptances, 10).get_page(page_param)

    #@silk_profile(name="Trade Offer My List- Get Context Data")
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        request = self.request
        show_closed = self.get_show_closed()
        context["show_closed"] = show_closed

        selected_friend_code = self.get_selected_friend_code()
        context["selected_friend_code"] = selected_friend_code
        context["friend_codes"] = request.user.friend_codes.all()

        # Use request params for initial full page load (could be None)
        offers_page = request.GET.get("offers_page")
        waiting_page = request.GET.get("waiting_page")
        other_page = request.GET.get("other_page")
        context["my_trade_offers_paginated"] = self.get_my_trade_offers_paginated(offers_page)
        context["trade_acceptances_waiting_paginated"] = self.get_trade_acceptances_waiting_paginated(waiting_page)
        context["other_party_trade_acceptances_paginated"] = self.get_other_party_trade_acceptances_paginated(other_page)

        return context

    #@silk_profile(name="Trade Offer My List- Render to Response")
    def render_to_response(self, context, **response_kwargs):
        # For AJAX requests, return only the paginated fragment.
        if self.request.headers.get("X-Requested-With") == "XMLHttpRequest":
            ajax_section = self.request.GET.get("ajax_section")
            page = self.request.GET.get("page")
            if ajax_section == "my_trade_offers":
                offers = self.get_my_trade_offers_paginated(page)
            elif ajax_section == "waiting_acceptances":
                offers = self.get_trade_acceptances_waiting_paginated(page)
            elif ajax_section == "other_party_acceptances":
                offers = self.get_other_party_trade_acceptances_paginated(page)
            else:
                # Fallback to my trade offers.
                offers = self.get_my_trade_offers_paginated(page)
            return render(self.request, "trades/_trade_offer_list_paginated.html", {"offers": offers})
        return super().render_to_response(context, **response_kwargs)

class TradeOfferDeleteView(LoginRequiredMixin, DeleteView):
    model = TradeOffer
    success_url = reverse_lazy("trade_offer_list")
    template_name = "trades/trade_offer_delete.html"

    def dispatch(self, request, *args, **kwargs):
        # Retrieve the object normally
        self.object = super().get_object()
        # Perform the permission check here
        if self.object.initiated_by_id not in request.user.friend_codes.values_list("id", flat=True):
            raise PermissionDenied("You are not authorized to delete or close this trade offer.")
        return super().dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        trade_offer = self.object
        terminal_states = [
            TradeAcceptance.AcceptanceState.THANKED_BY_INITIATOR,
            TradeAcceptance.AcceptanceState.THANKED_BY_ACCEPTOR,
            TradeAcceptance.AcceptanceState.THANKED_BY_BOTH,
            TradeAcceptance.AcceptanceState.REJECTED_BY_INITIATOR,
            TradeAcceptance.AcceptanceState.REJECTED_BY_ACCEPTOR,
        ]
        active_acceptances = trade_offer.acceptances.exclude(state__in=terminal_states)
        if trade_offer.acceptances.count() == 0:
            context["action"] = "delete"
        elif trade_offer.acceptances.count() > 0 and not active_acceptances.exists():
            context["action"] = "close"
        else:
            context["action"] = None
        return context

    def post(self, request, *args, **kwargs):
        trade_offer = self.object
        terminal_states = [
            TradeAcceptance.AcceptanceState.THANKED_BY_INITIATOR,
            TradeAcceptance.AcceptanceState.THANKED_BY_ACCEPTOR,
            TradeAcceptance.AcceptanceState.THANKED_BY_BOTH,
            TradeAcceptance.AcceptanceState.REJECTED_BY_INITIATOR,
            TradeAcceptance.AcceptanceState.REJECTED_BY_ACCEPTOR,
        ]
        active_acceptances = trade_offer.acceptances.exclude(state__in=terminal_states)
        if active_acceptances.exists():
            messages.error(
                request, 
                "Cannot close this trade offer while there are active acceptances. Please reject all acceptances before closing, or finish the trades."
            )
            context = self.get_context_data()
            return self.render_to_response(context)
        else:
            if trade_offer.acceptances.count() > 0:
                trade_offer.is_closed = True
                trade_offer.save(update_fields=["is_closed"])
                messages.success(request, "Trade offer has been marked as closed.")
                return HttpResponseRedirect(self.get_success_url())
            else:
                messages.success(request, "Trade offer has been deleted.")
                return super().delete(request, *args, **kwargs)

class TradeOfferSearchView(ListView):
    """
    Reworked trade offer search view using POST.

    This view allows users to search active trade offers based on the cards they have and/or want.
    The POST parameters (offered_cards and wanted_cards) are expected to be in the format 'card_id:quantity'.
    If both types of selections are provided, the resultant queryset must satisfy both conditions.
    Offers initiated by any of the user's friend codes are excluded.

    When the request is AJAX (via X-Requested-With header), only the search results fragment
    (_search_results.html) is rendered. On GET (initial page load), the search results queryset
    is empty.
    """
    model = TradeOffer
    context_object_name = "search_results"
    template_name = "trades/trade_offer_search.html"
    paginate_by = 10
    http_method_names = ["get", "post"]

    def parse_selections(self, selection_list):
        """
        Parse a list of selections (each formatted as 'card_id:quantity') into a list of tuples.
        Defaults the quantity to 1 if missing.
        """
        results = []
        for item in selection_list:
            parts = item.split(":")
            try:
                card_id = int(parts[0])
            except ValueError:
                continue  # Skip invalid values.
            qty = 1
            if len(parts) > 1:
                try:
                    qty = int(parts[1])
                except ValueError:
                    qty = 1
            results.append((card_id, qty))
        return results

    #@silk_profile(name="Trade Offer Search- Get Queryset")
    def get_queryset(self):
        # For a GET request (initial load), return an empty queryset.
        if self.request.method == "GET":
            return TradeOffer.objects.none()

        # Parse the POST data for offered and wanted selections.
        have_selections = self.parse_selections(self.request.POST.getlist("have_cards"))
        want_selections = self.parse_selections(self.request.POST.getlist("want_cards"))

        # If no selections are provided, return an empty queryset.
        if not have_selections and not want_selections:
            return TradeOffer.objects.none()

        qs = TradeOffer.objects.filter(
            is_closed=False,
        ).exclude(initiated_by__in=self.request.user.friend_codes.all())

        # Chain filters for offered selections (i.e. the user "has" cards).
        if have_selections:
            for card_id, qty in have_selections:
                qs = qs.filter(
                    trade_offer_want_cards__card_id=card_id,
                    trade_offer_want_cards__quantity__gte=qty,
                )

        # Chain filters for wanted selections (i.e. the user "wants" cards).
        if want_selections:
            for card_id, qty in want_selections:
                qs = qs.filter(
                    trade_offer_have_cards__card_id=card_id,
                    trade_offer_have_cards__quantity__gte=qty,
                )

        return qs.distinct()

    #@silk_profile(name="Trade Offer Search- Post")
    def post(self, request, *args, **kwargs):
        # For POST, simply process the search through get().
        return self.get(request, *args, **kwargs)

    #@silk_profile(name="Trade Offer Search- Get Context Data")
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        from cards.models import Card
        # Populate available_cards to re-populate the multiselects.
        context["cards"] = Card.objects.all().order_by("name")
        if self.request.method == "POST":
            context["have_cards"] = self.request.POST.getlist("have_cards")
            context["want_cards"] = self.request.POST.getlist("want_cards")
        else:
            context["have_cards"] = []
            context["want_cards"] = []
        return context

    #@silk_profile(name="Trade Offer Search- Render to Response")
    def render_to_response(self, context, **response_kwargs):
        """
        Render the AJAX fragment if the request is AJAX; otherwise, render the complete page.
        """
        if self.request.headers.get("X-Requested-With") == "XMLHttpRequest":
            from django.shortcuts import render
            return render(self.request, "trades/_search_results.html", context)
        else:
            return super().render_to_response(context, **response_kwargs)

class TradeOfferDetailView(DetailView):
    """
    Displays the details of a TradeOffer along with its active acceptances.
    If the offer is still open and the current user is not its initiator,
    an acceptance form is provided to create a new acceptance.
    """
    model = TradeOffer
    template_name = "trades/trade_offer_detail.html"

    #@silk_profile(name="Trade Offer Detail- Get Context Data")
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        trade_offer = self.get_object()
        screenshot_mode = self.request.GET.get("screenshot_mode")
        if screenshot_mode:
            context["show_friend_code"] = trade_offer.initiated_by.user.show_friend_code_on_link_previews
        context["screenshot_mode"] = screenshot_mode
        
        # Calculate the number of cards in each category.
        num_has = trade_offer.trade_offer_have_cards.count()
        num_wants = trade_offer.trade_offer_want_cards.count()
        num_cards = max(num_has, num_wants)

        # Define the aspect ratio.
        aspect_ratio = 1.91

        # Calculate a base height using our previous assumptions:
        #   - 80px per card row (with rows computed as round(num_cards/2))
        #   - plus 138px for header/footer.
        base_height = (round(num_cards / 2) * 56) + 138

        # Calculate a base width by assuming two columns of card badges.
        # Here we assume each card badge is 80px wide plus the same horizontal offset of 138px.
        if (num_wants + num_has) >= 4:
            base_width = (4 * 144) + 96
        else:
            base_width = (2 * 144) + 128

        if base_height > base_width:
            # The trade-offer card is taller than wide;
            # compute the width from the height.
            image_height = base_height
            image_width = int(round(image_height * aspect_ratio)) + 1
        else:
            # The trade-offer card is wider than tall;
            # compute the height from the width.
            image_width = base_width
            image_height = int(round(image_width / aspect_ratio))
        
        # Build the meta tags with the computed dimensions.
        title = f'Trade Offer from {trade_offer.initiated_by.in_game_name} ({trade_offer.initiated_by.friend_code})'
        context["meta"] = Meta(
            title=title,
            description=f'Has: {", ".join([card.card.name for card in trade_offer.trade_offer_have_cards.all()])} • \nWants: {", ".join([card.card.name for card in trade_offer.trade_offer_want_cards.all()])}',
            image_object={
                "url": f'http://localhost:8000{reverse_lazy("trade_offer_png", kwargs={"pk": trade_offer.pk})}',
                "type": "image/png",
                "width": image_width,
                "height": image_height,
            },
            twitter_type="summary_large_image",
            use_og=True,
            use_twitter=True,
            use_facebook=True,
            use_schemaorg=True,
        )
        
        # Define terminal (closed) acceptance states based on our new system:
        terminal_states = [
            TradeAcceptance.AcceptanceState.THANKED_BY_INITIATOR,
            TradeAcceptance.AcceptanceState.THANKED_BY_ACCEPTOR,
            TradeAcceptance.AcceptanceState.THANKED_BY_BOTH,
            TradeAcceptance.AcceptanceState.REJECTED_BY_INITIATOR,
            TradeAcceptance.AcceptanceState.REJECTED_BY_ACCEPTOR,
        ]
        
        # For example, if you want to separate active from terminal acceptances:
        context["acceptances"] = trade_offer.acceptances.all()
        
        # Option 1: Filter active acceptances using the queryset lookup.
        context["active_acceptances"] = trade_offer.acceptances.exclude(state__in=terminal_states)
        
        if self.request.user.is_authenticated:
            user_friend_codes = self.request.user.friend_codes.all()

            # Add context flag and deletion URL if the current user is the initiator
            if trade_offer.initiated_by in user_friend_codes:
                context["is_initiator"] = True
                context["delete_close_url"] = reverse_lazy("trade_offer_delete", kwargs={"pk": trade_offer.pk})
            else:
                context["is_initiator"] = False

            # Determine the user's default friend code (or fallback as needed).
            default_friend_code = self.request.user.default_friend_code or user_friend_codes.first()
            
            # If the current user is not the initiator and the offer is open, allow a new acceptance.
            if trade_offer.initiated_by not in user_friend_codes and not trade_offer.is_closed:
                context["acceptance_form"] = TradeAcceptanceCreateForm(
                    trade_offer=trade_offer,
                    friend_codes=user_friend_codes,
                    default_friend_code=default_friend_code
                )
        else:
            context["is_initiator"] = False
            context["delete_close_url"] = None
            context["acceptance_form"] = None

        return context

class TradeAcceptanceCreateView(LoginRequiredMixin, CreateView):
    """
    View to create a new TradeAcceptance.
    The URL should provide 'offer_pk' so that the proper TradeOffer can be identified.
    """
    model = TradeAcceptance
    form_class = TradeAcceptanceCreateForm
    template_name = "trades/trade_acceptance_create.html"

    def dispatch(self, request, *args, **kwargs):
        self.trade_offer = self.get_trade_offer()
        if self.trade_offer.initiated_by_id in request.user.friend_codes.values_list("id", flat=True) or self.trade_offer.is_closed:
            raise PermissionDenied("You cannot accept this trade offer.")
        if not request.user.friend_codes.exists():
            raise PermissionDenied("No friend codes available for your account.")
        return super().dispatch(request, *args, **kwargs)

    def get_trade_offer(self):
        return (
            TradeOffer.objects.get(pk=self.kwargs['offer_pk'])
        )

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['trade_offer'] = self.trade_offer
        kwargs['friend_codes'] = self.request.user.friend_codes.all()
        return kwargs

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["trade_offer"] = self.trade_offer
        return context

    def form_valid(self, form):
        form.instance.trade_offer = self.trade_offer
        self.object = form.save()
        return HttpResponseRedirect(self.get_success_url())

    def form_invalid(self, form):
        """
        If the form submission includes a 'next' URL (sent as a hidden field from the detail page),
        render the trade offer detail template for a better UX. Otherwise, fall back to the default
        CreateView behavior.
        """
        next_url = self.request.POST.get("next")
        if next_url:
            friend_codes = self.request.user.friend_codes.all()
            is_initiator = self.trade_offer.initiated_by in friend_codes
            context = {
                "object": self.trade_offer,
                "trade_offer": self.trade_offer,
                "acceptance_form": form,
                "friend_codes": friend_codes,
                "is_initiator": is_initiator,
                "delete_close_url": reverse_lazy("trade_offer_delete", kwargs={"pk": self.trade_offer.pk}) if is_initiator else None,
            }
            # Render the detail page with the form errors
            return render(self.request, "trades/trade_offer_detail.html", context)
        return super().form_invalid(form)

    def get_success_url(self):
        return reverse_lazy("trade_offer_detail", kwargs={"pk": self.trade_offer.pk})

class TradeAcceptanceUpdateView(LoginRequiredMixin, UpdateView):
    """
    View to update the state of an existing TradeAcceptance.
    The allowed state transitions are provided via the form.
    """
    model = TradeAcceptance
    form_class = TradeAcceptanceTransitionForm
    template_name = "trades/trade_acceptance_update.html"

    def dispatch(self, request, *args, **kwargs):
        self.object = self.get_object()
        if not request.user.friend_codes.exists():
            raise PermissionDenied("No friend codes available for your account.")
        friend_codes = request.user.friend_codes.values_list("id", flat=True)
        if self.object.accepted_by_id not in friend_codes and self.object.trade_offer.initiated_by_id not in friend_codes:
            raise PermissionDenied("You are not authorized to update this acceptance.")
        return super().dispatch(request, *args, **kwargs)

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        # Pass the current instance to the form so it can set proper allowed transitions.
        kwargs["instance"] = self.object
        kwargs["user"] = self.request.user
        return kwargs

    def form_valid(self, form):
        new_state = form.cleaned_data["state"]
        try:
            # Try to cast new_state to the enum member
            valid_state = TradeAcceptance.AcceptanceState(new_state)
        except ValueError:
            form.add_error("state", "Invalid state transition.")
            return self.form_invalid(form)
        try:
            form.instance.update_state(valid_state, self.request.user)
        except ValueError as e:
            form.add_error("state", str(e))
            return self.form_invalid(form)
        return HttpResponseRedirect(self.get_success_url())

    def get_success_url(self):
        return reverse_lazy("trade_offer_detail", kwargs={"pk": self.object.trade_offer.pk})

class TradeOfferPNGView(View):
    """
    Generate a PNG screenshot of the rendered trade offer detail page using Playwright.
    
    This view loads the trade offer detail page, waits for the trade offer element to render,
    simulates a click to expand extra badges, and then screenshots only the trade offer element.
    """
    
    def get(self, request, *args, **kwargs):
        # For demonstration purposes, get the first trade offer.
        # In production, you might want to identify the offer via a URL parameter.
        trade_offer = TradeOffer.objects.get(pk=kwargs['pk'])
        if not trade_offer:
            raise Http404("Trade offer not found")

        # Get the URL for the trade offer detail view.
        detail_url = request.build_absolute_uri(
            reverse_lazy("trade_offer_detail", kwargs={"pk": trade_offer.pk})+"?screenshot_mode=true"
        )

        

        with sync_playwright() as p:
            browser = p.chromium.launch(headless=True)
            context = browser.new_context(
                viewport={"width": 1280, "height": 800},
            )

            # If the request contains a Django session cookie,
            # add it to the browser context to bypass the login screen.
            session_cookie = request.COOKIES.get(settings.SESSION_COOKIE_NAME)
            if session_cookie:
                cookie = {
                    "name": settings.SESSION_COOKIE_NAME,
                    "value": session_cookie,
                    "domain": request.get_host().split(':')[0],
                    "path": "/",
                    "httpOnly": True,
                    "secure": not settings.DEBUG,
                }
                context.add_cookies([cookie])

            # Open a new page and navigate to the detail view.
            page = context.new_page()
            page.goto(detail_url, wait_until="networkidle")

            # Inject CSS to force transparency.
            page.add_style_tag(content="""
                html, body, .bg-base-200 {
                    background-color: rgba(255, 255, 255, 0) !important;
                }
            """)

            trade_offer_selector = ".trade-offer-card-screenshot"
            page.wait_for_selector(trade_offer_selector)

            # Simulate a click on the toggle button within the trade offer element
            # to force the extra details (e.g., extra badges) to expand.
            # We use a selector that targets the first svg with a "cursor-pointer" class inside the trade offer card.
            toggle_selector = f"{trade_offer_selector} svg.cursor-pointer"
            try:
                toggle = page.query_selector(toggle_selector)
                if toggle:
                    toggle.click()
                    # Wait for the CSS animation to complete (600ms as in your template)
                    page.wait_for_timeout(600)
            except Exception:
                # If the toggle is not found or clicking fails, proceed without expansion.
                pass

            # Locate the element containing the trade offer and capture its screenshot.
            element = page.query_selector(trade_offer_selector)
            if not element:
                browser.close()
                raise Http404("Trade offer element not found on page")

            png_bytes = element.screenshot(type="png", omit_background=True)
            browser.close()

        return HttpResponse(png_bytes, content_type="image/png")

class TradeOfferCreateConfirmView(LoginRequiredMixin, View):
    """
    Processes a two-step create for TradeOffer; on confirmation,
    commits the offer and shows form errors if any occur.
    """
    def post(self, request, *args, **kwargs):
        if "confirm" in request.POST:
            return self._commit_offer(request)
        elif "edit" in request.POST:
            return self._redirect_to_edit(request)
        elif "preview" in request.POST:
            return self._preview_offer(request)
        else:
            return self._preview_offer(request)

    def _commit_offer(self, request):
        """
        Commits the offer after confirmation. Any model ValidationError (for example,
        due to mismatched card rarities) is caught and added to the form errors so that
        it shows up in trade_offer_create.html.
        """
        # Instantiate the form with POST data.
        form = TradeOfferCreateForm(request.POST)
        # Ensure that the 'initiated_by' queryset is limited to the user's friend codes.
        form.fields["initiated_by"].queryset = request.user.friend_codes.all()
        if form.is_valid():
            try:
                trade_offer = form.save()
            except ValidationError as error:
                form.add_error(None, error)
                # Update the form's initial data so the template can safely reference have_cards/want_cards.
                form.initial = {
                    "have_cards": request.POST.getlist("have_cards"),
                    "want_cards": request.POST.getlist("want_cards"),
                    "initiated_by": request.POST.get("initiated_by"),
                }
                # Supply additional context required by trade_offer_create.html.
                from cards.models import Card
                context = {
                    "form": form,
                    "friend_codes": request.user.friend_codes.all(),
                    "selected_friend_code": (
                        request.user.default_friend_code or request.user.friend_codes.first()
                    ),
                    "cards": Card.objects.all().order_by("name", "rarity_level"),
                }
                return render(request, "trades/trade_offer_create.html", context)
            messages.success(request, "Trade offer created successfully!")
            return HttpResponseRedirect(reverse_lazy("trade_offer_list"))
        else:
            # When the form is not valid, update its initial data as well:
            form.initial = {
                "have_cards": request.POST.getlist("have_cards"),
                "want_cards": request.POST.getlist("want_cards"),
                "initiated_by": request.POST.get("initiated_by"),
            }
            from cards.models import Card
            context = {
                "form": form,
                "friend_codes": request.user.friend_codes.all(),
                "selected_friend_code": (
                    request.user.default_friend_code or request.user.friend_codes.first()
                ),
                "cards": Card.objects.all().order_by("name", "rarity_level"),
            }
            return render(request, "trades/trade_offer_create.html", context)
    
    def _redirect_to_edit(self, request):
        query_params = request.POST.copy()
        query_params.pop("csrfmiddlewaretoken", None)
        query_params.pop("edit", None)
        query_params.pop("confirm", None)
        query_params.pop("preview", None)
        from django.urls import reverse
        base_url = reverse("trade_offer_create")
        url_with_params = f"{base_url}?{query_params.urlencode()}"
        return HttpResponseRedirect(url_with_params)
    
    def _preview_offer(self, request):
        """
        Processes the preview action (existing logic remains unchanged).
        """
        form = TradeOfferCreateForm(request.POST)
        form.fields["initiated_by"].queryset = request.user.friend_codes.all()
        if not form.is_valid():
            # Re-render the creation template with errors.
            return render(request, "trades/trade_offer_create.html", {"form": form})

        # Parse the card selections for "have" and "want" cards.
        have_selections = self._parse_card_selections("have_cards")
        want_selections = self._parse_card_selections("want_cards")

        from cards.models import Card

        have_cards_ids = [card_id for card_id, _ in have_selections]
        cards_have_qs = Card.objects.filter(pk__in=have_cards_ids)
        cards_have_dict = {card.pk: card for card in cards_have_qs}

        # Define a dummy wrapper for a trade offer card entry.
        class DummyOfferCard:
            def __init__(self, card, quantity):
                self.card = card
                self.quantity = quantity
                self.qty_accepted = 0

        have_offer_cards = []
        for card_id, quantity in have_selections:
            card = cards_have_dict.get(card_id)
            if card:
                have_offer_cards.append(DummyOfferCard(card, quantity))

        want_cards_ids = [card_id for card_id, _ in want_selections]
        cards_want_qs = Card.objects.filter(pk__in=want_cards_ids)
        cards_want_dict = {card.pk: card for card in cards_want_qs}
        want_offer_cards = []
        for card_id, quantity in want_selections:
            card = cards_want_dict.get(card_id)
            if card:
                want_offer_cards.append(DummyOfferCard(card, quantity))

        # Mimic a related manager's all() method.
        class DummyManager:
            def __init__(self, items):
                self.items = items

            def all(self):
                return self.items

        # Create a dummy TradeOffer object with properties required by the render_trade_offer tag.
        class DummyTradeOffer:
            pass

        dummy_trade_offer = DummyTradeOffer()
        dummy_trade_offer.pk = 0  # a placeholder primary key
        dummy_trade_offer.hash = "preview"
        dummy_trade_offer.rarity_icon = ""
        dummy_trade_offer.trade_offer_have_cards = DummyManager(have_offer_cards)
        dummy_trade_offer.trade_offer_want_cards = DummyManager(want_offer_cards)
        dummy_trade_offer.acceptances = DummyManager([])  # no acceptances in preview
        dummy_trade_offer.initiated_by = form.cleaned_data["initiated_by"]

        # Pass along the POST data so that hidden inputs can be re-generated.
        context = {
            "dummy_trade_offer": dummy_trade_offer,
            "post_data": request.POST,
        }
        return render(request, "trades/trade_offer_confirm_create.html", context)

    def _parse_card_selections(self, key):
        """
        Parses card selections from POST data for a given key (e.g., 'have_cards' or 'want_cards').
        Selections are expected in the format 'card_id:quantity', defaulting quantity to 1 if missing.
        Returns a list of (card_id, quantity) tuples.
        """
        selections = self.request.POST.getlist(key)
        results = []
        for selection in selections:
            parts = selection.split(":")
            try:
                card_id = int(parts[0])
            except (ValueError, IndexError):
                continue
            quantity = 1
            if len(parts) > 1:
                try:
                    quantity = int(parts[1])
                except ValueError:
                    pass
            results.append((card_id, quantity))
        return results