cart/app.py

from __future__ import annotations
import path_setup  # noqa: F401  # adds shared_lib to sys.path

from decimal import Decimal
from pathlib import Path

from quart import g, abort
from jinja2 import FileSystemLoader, ChoiceLoader
from sqlalchemy import select

from shared.infrastructure.factory import create_base_app

from bp import (
    register_cart_overview,
    register_page_cart,
    register_cart_global,
    register_orders,
)
from bp.cart.services import (
    get_cart,
    total,
    get_calendar_cart_entries,
    calendar_total,
    get_ticket_cart_entries,
    ticket_total,
)
from bp.cart.services.page_cart import (
    get_cart_for_page,
    get_calendar_entries_for_page,
    get_tickets_for_page,
)
from bp.cart.services.ticket_groups import group_tickets


async def _load_cart():
    """Load the full cart for the cart app (before each request)."""
    g.cart = await get_cart(g.s)


async def cart_context() -> dict:
    """
    Cart app context processor.

    - cart / calendar_cart_entries / total / calendar_total: direct DB
      (cart app owns this data)
    - cart_count: derived from cart + calendar entries (for _mini.html)
    - menu_items: direct DB query via glue layer

    When g.page_post exists, cart and calendar_cart_entries are page-scoped.
    Global cart_count / cart_total stay global for cart-mini.
    """
    from shared.infrastructure.context import base_context
    from shared.services.navigation import get_navigation_tree

    ctx = await base_context()

    # Cart app owns cart data — use g.cart from _load_cart
    all_cart = getattr(g, "cart", None) or []
    all_cal = await get_calendar_cart_entries(g.s)
    all_tickets = await get_ticket_cart_entries(g.s)

    # Global counts for cart-mini (always global)
    cart_qty = sum(ci.quantity for ci in all_cart) if all_cart else 0
    ctx["cart_count"] = cart_qty + len(all_cal) + len(all_tickets)
    ctx["cart_total"] = (total(all_cart) or Decimal(0)) + (calendar_total(all_cal) or Decimal(0)) + (ticket_total(all_tickets) or Decimal(0))

    # Page-scoped data when viewing a page cart
    page_post = getattr(g, "page_post", None)
    if page_post:
        page_cart = await get_cart_for_page(g.s, page_post.id)
        page_cal = await get_calendar_entries_for_page(g.s, page_post.id)
        page_tickets = await get_tickets_for_page(g.s, page_post.id)
        ctx["cart"] = page_cart
        ctx["calendar_cart_entries"] = page_cal
        ctx["ticket_cart_entries"] = page_tickets
        ctx["page_post"] = page_post
        ctx["page_config"] = getattr(g, "page_config", None)
    else:
        ctx["cart"] = all_cart
        ctx["calendar_cart_entries"] = all_cal
        ctx["ticket_cart_entries"] = all_tickets

    ctx["ticket_groups"] = group_tickets(ctx.get("ticket_cart_entries", []))
    ctx["total"] = total
    ctx["calendar_total"] = calendar_total
    ctx["ticket_total"] = ticket_total

    ctx["menu_items"] = await get_navigation_tree(g.s)

    return ctx


def create_app() -> "Quart":
    from shared.models.page_config import PageConfig
    from shared.services.registry import services
    from services import register_domain_services

    app = create_base_app(
        "cart",
        context_fn=cart_context,
        before_request_fns=[_load_cart],
        domain_services_fn=register_domain_services,
    )

    # App-specific templates override shared templates
    app_templates = str(Path(__file__).resolve().parent / "templates")
    app.jinja_loader = ChoiceLoader([
        FileSystemLoader(app_templates),
        app.jinja_loader,
    ])

    app.jinja_env.globals["cart_quantity_url"] = lambda product_id: f"/quantity/{product_id}/"
    app.jinja_env.globals["cart_delete_url"] = lambda product_id: f"/delete/{product_id}/"

    # --- Page slug hydration (follows events/market app pattern) ---

    @app.url_value_preprocessor
    def pull_page_slug(endpoint, values):
        if values and "page_slug" in values:
            g.page_slug = values.pop("page_slug")

    @app.url_defaults
    def inject_page_slug(endpoint, values):
        slug = g.get("page_slug")
        if slug and "page_slug" not in values:
            if app.url_map.is_endpoint_expecting(endpoint, "page_slug"):
                values["page_slug"] = slug

    @app.before_request
    async def hydrate_page():
        slug = getattr(g, "page_slug", None)
        if not slug:
            return
        post = await services.blog.get_post_by_slug(g.s, slug)
        if not post or not post.is_page:
            abort(404)
        g.page_post = post
        g.page_config = (
            await g.s.execute(
                select(PageConfig).where(
                    PageConfig.container_type == "page",
                    PageConfig.container_id == post.id,
                )
            )
        ).scalar_one_or_none()

    # --- Blueprint registration ---
    # Static prefixes first, dynamic (page_slug) last

    # Orders blueprint
    app.register_blueprint(register_orders(url_prefix="/orders"))

    # Global routes (webhook, return, add — specific paths under /)
    app.register_blueprint(
        register_cart_global(url_prefix="/"),
        url_prefix="/",
    )

    # Cart overview at GET /
    app.register_blueprint(
        register_cart_overview(url_prefix="/"),
        url_prefix="/",
    )

    # Page cart at /<page_slug>/ (dynamic, matched last)
    app.register_blueprint(
        register_page_cart(url_prefix="/"),
        url_prefix="/<page_slug>",
    )

    # --- Reconcile stale pending orders on startup ---
    @app.before_serving
    async def _reconcile_pending_orders():
        """Check SumUp status for orders stuck in 'pending' with a checkout ID.

        Handles the case where SumUp webhooks fired while the service was down
        or were rejected (e.g. CSRF). Runs once on boot.
        """
        import logging
        from datetime import datetime, timezone, timedelta
        from sqlalchemy import select
        from sqlalchemy.orm import selectinload
        from shared.db.session import get_session
        from shared.models.order import Order
        from bp.cart.services.check_sumup_status import check_sumup_status

        log = logging.getLogger("cart.reconcile")

        try:
            async with get_session() as sess:
                async with sess.begin():
                    # Orders that are pending, have a SumUp checkout, and are
                    # older than 2 minutes (avoid racing with in-flight checkouts)
                    cutoff = datetime.now(timezone.utc) - timedelta(minutes=2)
                    result = await sess.execute(
                        select(Order)
                        .where(
                            Order.status == "pending",
                            Order.sumup_checkout_id.isnot(None),
                            Order.created_at < cutoff,
                        )
                        .options(selectinload(Order.page_config))
                        .limit(50)
                    )
                    stale_orders = result.scalars().all()

                    if not stale_orders:
                        return

                    log.info("Reconciling %d stale pending orders", len(stale_orders))
                    for order in stale_orders:
                        try:
                            await check_sumup_status(sess, order)
                            log.info(
                                "Order %d reconciled: %s",
                                order.id, order.status,
                            )
                        except Exception:
                            log.exception("Failed to reconcile order %d", order.id)
        except Exception:
            log.exception("Order reconciliation failed")

    return app


app = create_app()