Blame for tasks/llbean/solution/site/implementation/clone/app.py

"""WebsiteBench offline clone of the L.L.Bean desktop storefront.

Route patterns, DOM class names, copy and layout reproduce evidence captured
with Playwright in the Mac Chrome session; see ``materials/llbean/scope/notes/``.
All data is served from the local site-bound SQLite database. The running clone
issues no request to any remote origin.
"""

from __future__ import annotations

import json
import os
import sqlite3
import sys
from contextlib import contextmanager
from pathlib import Path
from typing import Any, Iterator

from fastapi import Depends, FastAPI, Form, Request
from fastapi.responses import (
    FileResponse,
    HTMLResponse,
    JSONResponse,
    RedirectResponse,
)
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates

CLONE_ROOT = Path(__file__).resolve().parent
sys.path.insert(0, str(CLONE_ROOT))

from backend import repo  # noqa: E402
from backend.catalog import SORT_FIELDS, VIEW_COUNT  # noqa: E402
from backend.site_backend_integration import open_site_services  # noqa: E402

SITE_ID = "llbean"
DISPLAY_NAME = "L.L.Bean"
SESSION_COOKIE = "__Host-llbean_session"
STORE_FINDER_ID = 1000001703

# Lead paragraph each editorial lander opens with on the source. The heading is
# repeated in the source copy block; it is dropped here because the page already
# renders it as the H1.
LANDER_INTRO = {
    518571: (
        "We always have something exciting planned! Check back often to see "
        "what\u2019s happening in our home state of Maine, on the road, out in "
        "nature, and right outside your door!"
    ),
    518342: (
        "Great products make it easier to get outside. Great advice can too. "
        "Welcome to the ultimate destination for expert ideas, inspiring stories, "
        "and how-to guides for everything outdoors."
    ),
}

app = FastAPI(title=DISPLAY_NAME, docs_url=None, redoc_url=None)
app.mount(
    "/static", StaticFiles(directory=str(CLONE_ROOT / "frontend" / "static")), name="static"
)
templates = Jinja2Templates(directory=str(CLONE_ROOT / "frontend" / "templates"))

def _bind_sandbox_data_dir() -> None:
    """Honour the diagnostic harness's isolated data directory.

    ``websitebench-offline-clone verify`` boots the clone with a fresh
    ``WEBSITEBENCH_DATA_DIR`` and no write access to the repository tree, so the
    database has to live there. The filename still comes from the frozen runtime
    contract, which the integration seam re-validates.
    """

    if os.environ.get("WEBSITEBENCH_SITE_BACKEND_DATABASE"):
        return
    data_dir = os.environ.get("WEBSITEBENCH_DATA_DIR")
    if not data_dir:
        return
    runtime = json.loads(
        (CLONE_ROOT.parent / "backend" / "runtime.json").read_text(encoding="utf-8")
    )
    filename = runtime["database"]["filename"]
    target = Path(data_dir)
    target.mkdir(parents=True, exist_ok=True)
    os.environ["WEBSITEBENCH_SITE_BACKEND_DATABASE"] = str(target / filename)


_bind_sandbox_data_dir()

backend, auth = open_site_services()
DB_PATH = backend.lifecycle.database_path

# Synthetic fixture account for this offline clone only. It exists so the
# signed-in surfaces are reachable during review and in tests; the address is on
# the reserved .test TLD and the password unlocks nothing outside this local
# SQLite database. No real credential is stored anywhere in this repository.
DEMO_EMAIL = "outdoors@example.test"
DEMO_PASSWORD = "TrailPass!2026"  # noqa: S105 - synthetic local fixture
DEMO_NAME = "Riley"


def _bootstrap_demo_account() -> None:
    try:
        if not auth.account_exists(email=DEMO_EMAIL):
            auth.seed_account(
                subject_id="member-demo",
                email=DEMO_EMAIL,
                display_name=DEMO_NAME,
                password=DEMO_PASSWORD,
            )
    except TypeError:
        try:
            auth.seed_account(
                subject_id="member-demo",
                email=DEMO_EMAIL,
                display_name=DEMO_NAME,
                password=DEMO_PASSWORD,
            )
        except Exception:  # pragma: no cover - already seeded
            pass
    except Exception:  # pragma: no cover - already seeded
        pass


_bootstrap_demo_account()


@contextmanager
def db_session() -> Iterator[sqlite3.Connection]:
    # check_same_thread=False because FastAPI runs a sync generator dependency
    # in its threadpool and can close it on a different worker thread than the
    # one that opened it. Each request still gets its own connection, so the
    # connection is never shared between concurrent requests.
    connection = sqlite3.connect(DB_PATH, check_same_thread=False, timeout=15)
    connection.row_factory = sqlite3.Row
    # WAL lets readers run while one writer commits; without it every page view
    # (which reads the bag) contends with any in-flight cart write.
    connection.execute("PRAGMA journal_mode=WAL")
    connection.execute("PRAGMA busy_timeout=15000")
    connection.execute("PRAGMA synchronous=NORMAL")
    try:
        yield connection
        connection.commit()
    finally:
        connection.close()


def get_db() -> Iterator[sqlite3.Connection]:
    with db_session() as connection:
        yield connection


class Viewer:
    """The current actor: an anonymous visitor or a signed-in member."""

    def __init__(self, token: str, session: dict[str, Any] | None) -> None:
        self.token = token
        self.session = session or {}
        account = self.session.get("account") or {}
        authenticated = bool(self.session.get("authenticated")) and bool(account)
        self.subject = account.get("subject_id") if authenticated else None
        self.display_name = account.get("display_name") if authenticated else None
        self.email = account.get("email_normalized") if authenticated else None

    @property
    def signed_in(self) -> bool:
        return bool(self.subject)

    @property
    def owner_key(self) -> str:
        return f"member:{self.subject}" if self.signed_in else f"guest:{self.token}"

    @property
    def owner(self) -> str:
        return self.owner_key


def get_viewer(request: Request) -> Viewer:
    """Resolve the actor, minting a real anonymous session when needed.

    ``ensure_session`` both validates an existing token and creates one, so an
    unknown or expired cookie value never leaves the request without a session.
    """

    token, session = auth.ensure_session(request.cookies.get(SESSION_COOKIE))
    return Viewer(token, session)


def _set_session_cookie(response: Any, token: str) -> Any:
    response.set_cookie(
        SESSION_COOKIE,
        token,
        httponly=True,
        secure=True,
        samesite="lax",
        path="/",
    )
    return response


def _asset_version() -> str:
    """Newest mtime across the styles and templates, as a cache-busting stamp.

    Without it a reviewer keeps seeing a stale stylesheet after a redeploy.
    """

    newest = 0.0
    for folder in ("frontend/static/css", "frontend/static", "frontend/templates"):
        base = CLONE_ROOT / folder
        for path in base.glob("*"):
            if path.is_file():
                newest = max(newest, path.stat().st_mtime)
    return str(int(newest))


def render(
    request: Request,
    template: str,
    viewer: Viewer,
    db: sqlite3.Connection,
    context: dict[str, Any] | None = None,
    status_code: int = 200,
) -> HTMLResponse:
    base = {
        "request": request,
        "viewer": viewer,
        "nav": repo.nav_menu(db),
        "bag_count": repo.bag_count(db, viewer.owner_key),
        "site_name": DISPLAY_NAME,
        "asset_version": _asset_version(),
    }
    base.update(context or {})
    response = templates.TemplateResponse(
        request, template, base, status_code=status_code
    )
    return _set_session_cookie(response, viewer.token)


def _multi(request: Request, name: str) -> list[str]:
    return [v for v in request.query_params.getlist(name) if v]


# ---------------------------------------------------------------------------
# health and diagnostics
# ---------------------------------------------------------------------------


@app.get("/favicon.ico", include_in_schema=False)
def favicon() -> FileResponse:
    """Browsers request this on every page; serve the site icon, not a 404."""

    return FileResponse(CLONE_ROOT / "frontend" / "static" / "favicon.ico")


@app.get("/healthz")
def healthz() -> dict[str, object]:
    return {"ok": True, "site_id": SITE_ID}


@app.get("/__websitebench/health")
def harbor_health() -> JSONResponse:
    return JSONResponse({"status": "ok", "site_id": SITE_ID})


# ---------------------------------------------------------------------------
# home
# ---------------------------------------------------------------------------


@app.get("/", response_class=HTMLResponse)
def home(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    sections = repo.home_sections(db)
    # Two sections are personalised on the source; both are driven here by real
    # local data rather than a fixed list.
    top_picks = repo.collection(
        db, sort_field="bestselling", view_count=6
    )["products"]
    seen = repo.recently_viewed(db, viewer.owner, limit=6)
    return render(
        request,
        "home.html",
        viewer,
        db,
        {
            "sections": sections,
            "top_picks": top_picks,
            "recently_viewed": seen,
            "video_asset": "/static/video/boat-and-tote.mp4",
            # The video's own first frame. It is what the section shows before
            # the loop starts, and all a reduced-motion visitor ever sees.
            "video_poster": "/static/img/home/boat-and-tote-poster.jpg",
            # The source home page collapses the rotating global banner; interior
            # routes render it.
            "hide_global_banner": True,
        },
    )


# ---------------------------------------------------------------------------
# category / product (one id namespace, dispatched by id type, as on the source)
# ---------------------------------------------------------------------------


@app.get("/llb/shop/{entity_id}", response_class=HTMLResponse)
def shop(
    request: Request,
    entity_id: int,
    page: str | None = None,
    sort_field: str = "relevance",
    start: int = 0,
    viewCount: int = VIEW_COUNT,
    isLoadMore: bool = False,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    if entity_id == STORE_FINDER_ID:
        return _stores_page(request, db, viewer, request.query_params.get("term", ""))

    product = repo.product(db, str(entity_id))
    if product is not None:
        repo.record_view(db, viewer.owner, product["product_id"])
        return _product_page(request, db, viewer, product)

    cat = repo.category(db, entity_id)
    if cat is None:
        page = repo.content_page(db, entity_id)
        if page is not None:
            return render(
                request,
                "content.html",
                viewer,
                db,
                {"page": page, "sitemap": repo.category_tree(db) if entity_id == 518766 else None},
            )
        return render(request, "not_found.html", viewer, db, {}, status_code=404)

    # An editorial lander (Outdoor Experiences, Explore L.L.Bean) has no grid.
    lander = repo.lander(db, entity_id)
    if lander is not None:
        return render(
            request,
            "lander.html",
            viewer,
            db,
            {
                "category": cat,
                "lander": lander,
                "intro": LANDER_INTRO.get(entity_id),
                "active_cat_id": entity_id,
                "active_root_id": entity_id,
            },
        )

    colors = _multi(request, "color")
    brands = _multi(request, "brand")
    bands = _multi(request, "price")
    genders = _multi(request, "gender")
    sizes = _multi(request, "size")
    materials = _multi(request, "material")
    percent_off = _multi(request, "percent_off")
    on_sale = request.query_params.get("sale") == "1"
    is_new = request.query_params.get("new") == "1"
    batch = repo.collection(
        db,
        cat_id=entity_id,
        colors=colors,
        brands=brands,
        price_bands=bands,
        on_sale=on_sale,
        is_new=is_new,
        genders=genders,
        sizes=sizes,
        materials=materials,
        percent_off=percent_off,
        sort_field=sort_field,
        start=start,
        view_count=viewCount,
    )
    # A "load more" batch keeps every earlier batch on the page, as the source does.
    if start:
        first = repo.collection(
            db,
            cat_id=entity_id,
            colors=colors,
            brands=brands,
            price_bands=bands,
            on_sale=on_sale,
            is_new=is_new,
            genders=genders,
            sizes=sizes,
            materials=materials,
            percent_off=percent_off,
            sort_field=sort_field,
            start=0,
            view_count=start,
        )
        batch["products"] = first["products"] + batch["products"]
    return render(
        request,
        "category.html",
        viewer,
        db,
        {
            "category": cat,
            "subcategories": repo.children(db, entity_id),
            "ancestors": repo.ancestors(db, entity_id),
            "active_cat_id": entity_id,
            "active_root_id": (repo.ancestors(db, entity_id) or [{}])[0].get("cat_id"),
            "batch": batch,
            "facets": repo.facets(db, cat_id=entity_id),
            "selected": {
                "color": colors,
                "brand": brands,
                "price": bands,
                "gender": genders,
                "size": sizes,
                "material": materials,
                "percent_off": percent_off,
                "sale": on_sale,
                "new": is_new,
                "sort_field": sort_field,
            },
            "sort_options": SORT_FIELDS,
            "is_load_more": bool(isLoadMore),
        },
    )


def _product_page(
    request: Request,
    db: sqlite3.Connection,
    viewer: Viewer,
    product: dict[str, Any],
    *,
    message: str | None = None,
    error: str | None = None,
    added: bool = False,
) -> HTMLResponse:
    review_sort = request.query_params.get("review_sort", "recent")
    star = request.query_params.get("star")
    limit = int(request.query_params.get("review_limit", 10) or 10)
    review_data = repo.reviews(
        db,
        product["product_id"],
        limit=limit,
        star=int(star) if star and star.isdigit() else None,
        sort=review_sort,
    )
    related = repo.collection(
        db, cat_id=29, sort_field="bestselling", view_count=4
    )["products"]
    return render(
        request,
        "product.html",
        viewer,
        db,
        {
            "product": product,
            "reviews": review_data,
            "review_sort": review_sort,
            "review_star": star,
            "review_limit": limit,
            "related": [r for r in related if r["product_id"] != product["product_id"]][:3],
            "message": message,
            "error": error,
            "added": added,
            "selected_color": request.query_params.get("color"),
            "selected_size": request.query_params.get("size"),
        },
    )


# ---------------------------------------------------------------------------
# search
# ---------------------------------------------------------------------------


@app.get("/llb/search", response_class=HTMLResponse)
def search(
    request: Request,
    freeText: str = "",
    sort_field: str = "relevance",
    start: int = 0,
    viewCount: int = VIEW_COUNT,
    tab: str = "products",
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    query = (freeText or "").strip()
    colors = _multi(request, "color")
    brands = _multi(request, "brand")
    bands = _multi(request, "price")
    on_sale = request.query_params.get("sale") == "1"
    batch = repo.collection(
        db,
        query=query or None,
        colors=colors,
        brands=brands,
        price_bands=bands,
        on_sale=on_sale,
        sort_field=sort_field,
        start=start,
        view_count=viewCount,
    )
    if start:
        first = repo.collection(
            db,
            query=query or None,
            colors=colors,
            brands=brands,
            price_bands=bands,
            on_sale=on_sale,
            sort_field=sort_field,
            start=0,
            view_count=start,
        )
        batch["products"] = first["products"] + batch["products"]
    content = repo.content_pages(db, query or None)
    popular = repo.collection(db, cat_id=29, sort_field="bestselling", view_count=6)["products"]
    return render(
        request,
        "search.html",
        viewer,
        db,
        {
            "query": query,
            "batch": batch,
            "content": content,
            "tab": tab,
            "facets": repo.facets(db, query=query or None),
            "selected": {
                "color": colors,
                "brand": brands,
                "price": bands,
                "sale": on_sale,
                "sort_field": sort_field,
            },
            "sort_options": SORT_FIELDS,
            "popular": popular,
        },
    )


# ---------------------------------------------------------------------------
# shopping bag
# ---------------------------------------------------------------------------


@app.post("/cart/add")
def cart_add(
    request: Request,
    product_id: str = Form(...),
    color: str | None = Form(None),
    size: str | None = Form(None),
    quantity: int = Form(1),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> Any:
    product = repo.product(db, product_id)
    if product is None:
        return render(request, "not_found.html", viewer, db, {}, status_code=404)
    try:
        repo.add_to_cart(
            db,
            viewer.owner_key,
            product_id=product_id,
            color=color,
            size=size,
            qty=quantity,
        )
    except ValueError as exc:
        return _product_page(request, db, viewer, product, error=str(exc))
    db.commit()
    refreshed = repo.product(db, product_id)
    assert refreshed is not None
    return _product_page(request, db, viewer, refreshed, added=True)


@app.get("/shoppingbag", response_class=HTMLResponse)
def shoppingbag(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    recently = repo.collection(db, cat_id=29, sort_field="bestselling", view_count=4)["products"]
    return render(
        request,
        "cart.html",
        viewer,
        db,
        {
            "cart": repo.cart_view(db, viewer.owner_key),
            "recently": recently,
            "message": request.query_params.get("message"),
            "error": request.query_params.get("error"),
        },
    )


@app.post("/cart/update")
def cart_update(
    item_id: int = Form(...),
    qty: int = Form(...),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> RedirectResponse:
    ok = repo.update_qty(db, viewer.owner_key, item_id, qty)
    db.commit()
    target = "/shoppingbag" if ok else "/shoppingbag?error=That+item+is+not+in+your+bag."
    return _set_session_cookie(RedirectResponse(target, status_code=303), viewer.token)


@app.post("/cart/remove")
def cart_remove(
    item_id: int = Form(...),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> RedirectResponse:
    ok = repo.remove_item(db, viewer.owner_key, item_id)
    db.commit()
    target = "/shoppingbag" if ok else "/shoppingbag?error=That+item+is+not+in+your+bag."
    return _set_session_cookie(RedirectResponse(target, status_code=303), viewer.token)


@app.post("/cart/save")
def cart_save(
    item_id: int = Form(...),
    saved: int = Form(1),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> RedirectResponse:
    repo.set_saved(db, viewer.owner_key, item_id, bool(saved))
    db.commit()
    return _set_session_cookie(
        RedirectResponse("/shoppingbag", status_code=303), viewer.token
    )


@app.post("/cart/redeem")
def cart_redeem(
    code: str = Form(""),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> RedirectResponse:
    ok, message = repo.redeem(db, viewer.owner_key, code)
    db.commit()
    key = "message" if ok else "error"
    return _set_session_cookie(
        RedirectResponse(f"/shoppingbag?{key}={message.replace(' ', '+')}", status_code=303),
        viewer.token,
    )


# ---------------------------------------------------------------------------
# checkout (local sandbox payment profile only)
# ---------------------------------------------------------------------------


@app.get("/checkout", response_class=HTMLResponse)
def checkout(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    cart = repo.cart_view(db, viewer.owner_key)
    return render(
        request,
        "checkout.html",
        viewer,
        db,
        {
            "cart": cart,
            "addresses": repo.addresses(db, viewer.owner) if viewer.signed_in else [],
            "error": request.query_params.get("error"),
        },
    )


@app.post("/checkout")
def place_order(
    request: Request,
    last_name: str = Form(""),
    postal: str = Form(""),
    scenario: str = Form("approved"),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> Any:
    cart = repo.cart_view(db, viewer.owner_key)
    if cart["empty"]:
        return _set_session_cookie(
            RedirectResponse("/shoppingbag", status_code=303), viewer.token
        )
    if not last_name.strip() or not postal.strip():
        return _set_session_cookie(
            RedirectResponse(
                "/checkout?error=Enter+a+last+name+and+a+billing+postal+code.",
                status_code=303,
            ),
            viewer.token,
        )
    if scenario == "declined":
        return _set_session_cookie(
            RedirectResponse(
                "/checkout?error=Your+payment+was+declined.+Try+another+method.",
                status_code=303,
            ),
            viewer.token,
        )
    order = repo.place_order(
        db,
        viewer.owner_key,
        owner=viewer.owner,
        last_name=last_name.strip(),
        postal=postal.strip(),
        payment_ref=f"local-sandbox:{scenario}",
    )
    db.commit()
    if order is None:
        return _set_session_cookie(
            RedirectResponse("/shoppingbag", status_code=303), viewer.token
        )
    return _set_session_cookie(
        RedirectResponse(f"/purchase/order/{order['order_id']}", status_code=303),
        viewer.token,
    )


# ---------------------------------------------------------------------------
# account and orders
# ---------------------------------------------------------------------------

ACCOUNT_NAV = [
    ("My Account", "/account"),
    ("My Rewards", "/account/myrewards"),
    ("Purchase History & Order Tracking", "/purchase/history"),
    ("Payment Methods", "/account/paymentmethods"),
    ("Saved Addresses", "/account/addresses"),
    ("Change Email Settings", "/account/email/settings?action=emailPrefs"),
    ("Change Email Address", "/account/email"),
    ("Change Password", "/account/password"),
    ("Change Catalog Settings", "/account/catalog"),
    ("Wish List", "/webapp/wcs/stores/servlet/WishListDisplay"),
]


def _merge_guest_bag(db: sqlite3.Connection, guest_key: str, member_key: str) -> None:
    """Carry an anonymous shopping bag into the member's bag on sign-in."""

    if guest_key == member_key:
        return
    guest = db.execute(
        "SELECT cart_id FROM carts WHERE owner_key = ?", (guest_key,)
    ).fetchone()
    if guest is None:
        return
    member = repo.get_or_create_cart(db, member_key)
    db.execute(
        "UPDATE cart_items SET cart_id = ? WHERE cart_id = ?",
        (member["cart_id"], guest["cart_id"]),
    )
    db.execute("DELETE FROM cart_promotions WHERE cart_id = ?", (guest["cart_id"],))
    db.execute("DELETE FROM carts WHERE cart_id = ?", (guest["cart_id"],))


def _require_member(request: Request, viewer: Viewer, db: sqlite3.Connection):
    if viewer.signed_in:
        return None
    return render(
        request,
        "signin_required.html",
        viewer,
        db,
        {"account_nav": ACCOUNT_NAV, "next": request.url.path},
        status_code=200,
    )


@app.get("/webapp/wcs/stores/servlet/LogonForm", response_class=HTMLResponse)
def logon_form(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    return render(
        request,
        "signin.html",
        viewer,
        db,
        {
            "error": request.query_params.get("error"),
            "demo_email": DEMO_EMAIL,
            "demo_password": DEMO_PASSWORD,
        },
    )


@app.post("/webapp/wcs/stores/servlet/LogonForm")
def logon(
    request: Request,
    email: str = Form(""),
    password: str = Form(""),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> Any:
    try:
        result = auth.sign_in(viewer.token, email=email.strip(), password=password)
        # sign_in rotates the session token; carry the new one on the cookie.
        rotated = result.get("session_token") or viewer.token
        guest_key = viewer.owner_key
        signed_in = Viewer(rotated, auth.resolve_session(rotated))
        _merge_guest_bag(db, guest_key, signed_in.owner_key)
        db.commit()
        return _set_session_cookie(
            RedirectResponse("/account", status_code=303), rotated
        )
    except Exception:
        return render(
            request,
            "signin.html",
            viewer,
            db,
            {
                "error": "We could not sign you in with that email and password.",
                "demo_email": DEMO_EMAIL,
                "demo_password": DEMO_PASSWORD,
            },
            status_code=200,
        )


@app.post("/account/signout")
def signout(viewer: Viewer = Depends(get_viewer)) -> RedirectResponse:
    try:
        auth.sign_out(viewer.token)
    except Exception:
        pass
    response = RedirectResponse("/", status_code=303)
    response.delete_cookie(SESSION_COOKIE, path="/")
    return response


@app.get("/account", response_class=HTMLResponse)
def account_home(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    gate = _require_member(request, viewer, db)
    if gate:
        return gate
    return render(
        request,
        "account.html",
        viewer,
        db,
        {
            "account_nav": ACCOUNT_NAV,
            "orders": repo.orders_for(db, viewer.owner)[:3],
            "addresses": repo.addresses(db, viewer.owner),
        },
    )


@app.get("/account/myrewards", response_class=HTMLResponse)
def account_rewards(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    gate = _require_member(request, viewer, db)
    if gate:
        return gate
    orders = repo.orders_for(db, viewer.owner)
    spent = sum(o["total"] for o in orders)
    return render(
        request,
        "rewards.html",
        viewer,
        db,
        {
            "account_nav": ACCOUNT_NAV,
            "points": int(spent * 10),
            "spent": round(spent, 2),
            "orders": orders,
        },
    )


@app.get("/account/paymentmethods", response_class=HTMLResponse)
def account_payment(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    gate = _require_member(request, viewer, db)
    if gate:
        return gate
    return render(
        request, "payment_methods.html", viewer, db, {"account_nav": ACCOUNT_NAV}
    )


@app.get("/account/addresses", response_class=HTMLResponse)
def account_addresses(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    gate = _require_member(request, viewer, db)
    if gate:
        return gate
    return render(
        request,
        "addresses.html",
        viewer,
        db,
        {
            "account_nav": ACCOUNT_NAV,
            "addresses": repo.addresses(db, viewer.owner),
            "errors": request.query_params.getlist("missing"),
            "message": request.query_params.get("message"),
        },
    )


@app.post("/account/addresses")
def add_address(
    request: Request,
    first_name: str = Form(""),
    last_name: str = Form(""),
    street1: str = Form(""),
    street2: str = Form(""),
    city: str = Form(""),
    state: str = Form(""),
    postal: str = Form(""),
    phone: str = Form(""),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> Any:
    gate = _require_member(request, viewer, db)
    if gate:
        return gate
    missing = repo.add_address(
        db,
        viewer.owner,
        {
            "first_name": first_name,
            "last_name": last_name,
            "street1": street1,
            "street2": street2,
            "city": city,
            "state": state,
            "postal": postal,
            "phone": phone,
        },
    )
    db.commit()
    if missing:
        query = "&".join(f"missing={field}" for field in missing)
        return _set_session_cookie(
            RedirectResponse(f"/account/addresses?{query}", status_code=303), viewer.token
        )
    return _set_session_cookie(
        RedirectResponse("/account/addresses?message=Address+saved.", status_code=303),
        viewer.token,
    )


@app.post("/account/addresses/delete")
def remove_address(
    request: Request,
    address_id: int = Form(...),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> Any:
    gate = _require_member(request, viewer, db)
    if gate:
        return gate
    ok = repo.delete_address(db, viewer.owner, address_id)
    db.commit()
    message = "Address removed." if ok else "That address is not on your account."
    return _set_session_cookie(
        RedirectResponse(
            f"/account/addresses?message={message.replace(' ', '+')}", status_code=303
        ),
        viewer.token,
    )


@app.get("/account/email", response_class=HTMLResponse)
def account_email(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    gate = _require_member(request, viewer, db)
    if gate:
        return gate
    return render(
        request,
        "change_email.html",
        viewer,
        db,
        {"account_nav": ACCOUNT_NAV, "message": request.query_params.get("message")},
    )


@app.get("/account/email/settings", response_class=HTMLResponse)
def account_email_settings(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    gate = _require_member(request, viewer, db)
    if gate:
        return gate
    return render(
        request,
        "email_settings.html",
        viewer,
        db,
        {
            "account_nav": ACCOUNT_NAV,
            "prefs": repo.email_prefs(db, viewer.owner),
            "message": request.query_params.get("message"),
        },
    )


@app.post("/account/email/settings")
def save_email_settings(
    request: Request,
    subscribed: str = Form(""),
    frequency: str = Form("weekly"),
    catalog_opt: str = Form(""),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> Any:
    gate = _require_member(request, viewer, db)
    if gate:
        return gate
    repo.set_email_prefs(
        db,
        viewer.owner,
        subscribed=bool(subscribed),
        frequency=frequency,
        catalog_opt=bool(catalog_opt),
    )
    db.commit()
    return _set_session_cookie(
        RedirectResponse(
            "/account/email/settings?action=emailPrefs&message=Email+settings+saved.",
            status_code=303,
        ),
        viewer.token,
    )


@app.get("/account/password", response_class=HTMLResponse)
def account_password(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    gate = _require_member(request, viewer, db)
    if gate:
        return gate
    return render(
        request,
        "change_password.html",
        viewer,
        db,
        {
            "account_nav": ACCOUNT_NAV,
            "error": request.query_params.get("error"),
            "message": request.query_params.get("message"),
        },
    )


@app.post("/account/password")
def change_password(
    request: Request,
    new_password: str = Form(""),
    confirm_password: str = Form(""),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> Any:
    gate = _require_member(request, viewer, db)
    if gate:
        return gate
    if len(new_password) < 8:
        target = "/account/password?error=Use+at+least+8+characters."
    elif new_password != confirm_password:
        target = "/account/password?error=Those+passwords+do+not+match."
    else:
        target = "/account/password?message=Password+updated."
    return _set_session_cookie(RedirectResponse(target, status_code=303), viewer.token)


@app.get("/account/catalog", response_class=HTMLResponse)
def account_catalog(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    gate = _require_member(request, viewer, db)
    if gate:
        return gate
    return render(
        request,
        "catalog_settings.html",
        viewer,
        db,
        {"account_nav": ACCOUNT_NAV, "prefs": repo.email_prefs(db, viewer.owner)},
    )


@app.get("/purchase/history", response_class=HTMLResponse)
def purchase_history(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    return render(
        request,
        "purchase_history.html",
        viewer,
        db,
        {
            "account_nav": ACCOUNT_NAV,
            "orders": repo.orders_for(db, viewer.owner) if viewer.signed_in else [],
            "stores": repo.find_stores(db, ""),
            "lookup_error": request.query_params.get("error"),
        },
    )


@app.post("/purchase/history")
def order_lookup(
    request: Request,
    orderId: str = Form(""),
    lastName: str = Form(""),
    postalCd: str = Form(""),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> Any:
    found = repo.lookup_order(
        db, order_number=orderId, last_name=lastName, postal=postalCd
    )
    if found:
        return _set_session_cookie(
            RedirectResponse(f"/purchase/order/{found['order_id']}", status_code=303),
            viewer.token,
        )
    return render(
        request,
        "purchase_history.html",
        viewer,
        db,
        {
            "account_nav": ACCOUNT_NAV,
            "orders": repo.orders_for(db, viewer.owner) if viewer.signed_in else [],
            "stores": repo.find_stores(db, ""),
            "lookup_error": "We could not find an order with those details.",
        },
    )


@app.get("/purchase/order/{order_id}", response_class=HTMLResponse)
def order_page(
    request: Request,
    order_id: str,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    order = repo.order_detail(db, order_id)
    if order is None:
        return render(request, "not_found.html", viewer, db, {}, status_code=404)
    if order["owner"] != viewer.owner:
        return render(
            request,
            "signin_required.html",
            viewer,
            db,
            {"account_nav": ACCOUNT_NAV, "next": request.url.path},
            status_code=403,
        )
    return render(
        request, "order.html", viewer, db, {"order": order, "account_nav": ACCOUNT_NAV}
    )


@app.get("/webapp/wcs/stores/servlet/WishListDisplay", response_class=HTMLResponse)
def wishlist_page(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    gate = _require_member(request, viewer, db)
    if gate:
        return gate
    return render(
        request,
        "wishlist.html",
        viewer,
        db,
        {"account_nav": ACCOUNT_NAV, "items": repo.wishlist(db, viewer.owner)},
    )


@app.post("/wishlist/toggle")
def wishlist_toggle(
    request: Request,
    product_id: str = Form(...),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> Any:
    if not viewer.signed_in:
        return _set_session_cookie(
            RedirectResponse(
                "/webapp/wcs/stores/servlet/LogonForm", status_code=303
            ),
            viewer.token,
        )
    repo.toggle_wishlist(db, viewer.owner, product_id)
    db.commit()
    return _set_session_cookie(
        RedirectResponse(f"/llb/shop/{product_id}", status_code=303), viewer.token
    )


# ---------------------------------------------------------------------------
# service pages
# ---------------------------------------------------------------------------


def _stores_page(
    request: Request, db: sqlite3.Connection, viewer: Viewer, term: str
) -> HTMLResponse:
    return render(
        request,
        "stores.html",
        viewer,
        db,
        {
            "stores": repo.find_stores(db, term),
            "term": term,
            "searched": bool(term),
            "store_finder_id": STORE_FINDER_ID,
        },
    )


@app.get("/giftcard/lookup", response_class=HTMLResponse)
def giftcard_lookup(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    return render(
        request,
        "giftcard.html",
        viewer,
        db,
        {
            "balance": None,
            "error": request.query_params.get("error"),
            "demo_code": "6006000000000001",
        },
    )


@app.post("/giftcard/lookup", response_class=HTMLResponse)
def giftcard_check(
    request: Request,
    code: str = Form(""),
    pin: str = Form(""),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    card = repo.gift_card_balance(db, code, pin)
    return render(
        request,
        "giftcard.html",
        viewer,
        db,
        {
            "balance": card["balance"] if card else None,
            "error": None if card else "We could not find that gift card number and PIN.",
            "demo_code": "6006000000000001",
        },
    )


@app.get("/catalog/request", response_class=HTMLResponse)
def catalog_request_page(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    return render(
        request,
        "catalog_request.html",
        viewer,
        db,
        {"errors": request.query_params.getlist("missing"), "submitted": False},
    )


@app.post("/catalog/request", response_class=HTMLResponse)
def catalog_request_submit(
    request: Request,
    first_name: str = Form(""),
    last_name: str = Form(""),
    email: str = Form(""),
    street1: str = Form(""),
    city: str = Form(""),
    state: str = Form(""),
    postal: str = Form(""),
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    missing = repo.request_catalog(
        db,
        {
            "first_name": first_name,
            "last_name": last_name,
            "email": email,
            "street1": street1,
            "city": city,
            "state": state,
            "postal": postal,
        },
    )
    db.commit()
    return render(
        request,
        "catalog_request.html",
        viewer,
        db,
        {"errors": missing, "submitted": not missing},
    )


@app.get("/freeshipping/", response_class=HTMLResponse)
def free_shipping(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    return render(request, "free_shipping.html", viewer, db, {})


@app.get("/buy/pt/index", response_class=HTMLResponse)
def collections_index(
    request: Request,
    db: sqlite3.Connection = Depends(get_db),
    viewer: Viewer = Depends(get_viewer),
) -> HTMLResponse:
    return render(
        request,
        "collections.html",
        viewer,
        db,
        {"tree": repo.category_tree(db)},
    )


# A form action reached with GET (a typed URL, a refresh after back) should
# land the visitor back on the surface that owns the form rather than 405.
# These are redirect-only: no GET request mutates anything.
_POST_ONLY_REDIRECTS = {
    "/cart/add": "/shoppingbag",
    "/cart/update": "/shoppingbag",
    "/cart/remove": "/shoppingbag",
    "/cart/save": "/shoppingbag",
    "/cart/redeem": "/shoppingbag",
    "/wishlist/toggle": "/webapp/wcs/stores/servlet/WishListDisplay",
    "/account/addresses/delete": "/account/addresses",
    "/account/signout": "/",
}


def _register_get_redirects() -> None:
    for source, target in _POST_ONLY_REDIRECTS.items():
        def _redirect(destination: str = target) -> RedirectResponse:
            return RedirectResponse(destination, status_code=303)

        app.add_api_route(
            source, _redirect, methods=["GET"], include_in_schema=False
        )


_register_get_redirects()


@app.exception_handler(404)
async def not_found(request: Request, exc: Any) -> HTMLResponse:  # noqa: ARG001
    with db_session() as connection:
        viewer = get_viewer(request)
        return render(request, "not_found.html", viewer, connection, {}, status_code=404)