"""Curology's stateful, zero-remote WebsiteBench clone."""

from __future__ import annotations

from functools import lru_cache
from pathlib import Path
from typing import Any

from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse, JSONResponse, PlainTextResponse, RedirectResponse
from fastapi.staticfiles import StaticFiles
from pydantic import BaseModel, Field

import ui
from backend.curology_store import (
    CurologyPermissionError,
    CurologyStore,
    CurologyTransitionError,
    CurologyValidationError,
)
from backend.site_backend_integration import open_site_services
from websitebench.local_clone_auth import AuthError, LocalAuthStore
from websitebench.site_backend import PaymentError, SiteBackend


SITE_ID = "curology"
DISPLAY_NAME = "Curology"
STATIC_ROOT = Path(__file__).resolve().parent / "static"
app = FastAPI(title=DISPLAY_NAME, docs_url=None, redoc_url=None)
app.mount("/static", StaticFiles(directory=STATIC_ROOT), name="static")


@app.get("/robots.txt", response_class=PlainTextResponse)
def robots_txt() -> str:
    return "User-agent: *\nDisallow:\n"


@app.get("/llms.txt", response_class=PlainTextResponse)
def llms_txt() -> str:
    return """# Curology offline WebsiteBench simulation

> Public routes are local-only. No medical care or external transaction occurs.

## Public local pages

- [Home](/)
- [Products](/shop)
- [Why Curology](/why-curology)
- [Reviews](/reviews)
- [Skincare 101](/skincare-101)
"""


@lru_cache(maxsize=1)
def services() -> tuple[SiteBackend, LocalAuthStore, CurologyStore]:
    backend, auth = open_site_services()
    store = CurologyStore(backend, auth)
    store.seed_demo()
    return backend, auth, store


class Context:
    def __init__(self, request: Request) -> None:
        self.backend, self.auth, self.store = services()
        cookie_name = self.backend.session_cookie["name"]
        self.incoming_token = request.cookies.get(cookie_name)
        self.token, self.session = self.auth.ensure_session(self.incoming_token)
        digest = self.auth.session_owner_digest(self.token)
        self.actor = self.store.actor(self.session, digest)

    @property
    def account(self) -> dict[str, Any] | None:
        return self.actor.account

    def set_token(self, token: str) -> None:
        self.token = token
        resolved = self.auth.resolve_session(token)
        if resolved is None:
            raise RuntimeError("rotated local session was not persisted")
        self.session = resolved
        digest = self.auth.session_owner_digest(token)
        self.actor = self.store.actor(resolved, digest)

    def apply_cookie(self, response: Any) -> None:
        if self.token == self.incoming_token:
            return
        facts = self.backend.session_cookie
        response.set_cookie(
            key=str(facts["name"]),
            value=self.token,
            secure=bool(facts["secure"]),
            httponly=bool(facts["httponly"]),
            samesite=str(facts["samesite"]).lower(),
            path=str(facts["path"]),
        )


def page(
    request: Request,
    renderer: Any,
    *args: Any,
    status_code: int = 200,
) -> HTMLResponse:
    context = Context(request)
    response = HTMLResponse(
        renderer(context.account, *args),
        status_code=status_code,
    )
    context.apply_cookie(response)
    return response


def api_response(
    context: Context, payload: dict[str, Any], *, status_code: int = 200
) -> JSONResponse:
    response = JSONResponse(payload, status_code=status_code)
    context.apply_cookie(response)
    return response


def api_error(context: Context, exc: Exception, *, status_code: int = 400) -> JSONResponse:
    return api_response(context, {"detail": str(exc)}, status_code=status_code)


def require_account_page(request: Request, next_url: str) -> tuple[Context, RedirectResponse | None]:
    context = Context(request)
    if context.actor.authenticated:
        return context, None
    response = RedirectResponse(f"/auth/login?next={next_url}", status_code=303)
    context.apply_cookie(response)
    return context, response


def safe_next(value: str) -> str:
    return value if value.startswith("/") and not value.startswith("//") else "/account"


class AnswerPayload(BaseModel):
    value: str
    idempotency_key: str


class PlanPayload(BaseModel):
    plan_tier: str
    quantity: int = Field(ge=1, le=4)
    frequency: str
    product_option: str
    idempotency_key: str


class ShippingPayload(BaseModel):
    name: str
    address: str
    city: str
    region: str
    postal: str
    email: str
    idempotency_key: str


class PaymentPayload(BaseModel):
    scenario_id: str
    fingerprint: str = Field(min_length=64, max_length=64)
    idempotency_key: str


class IdempotentPayload(BaseModel):
    idempotency_key: str


class ModifyPayload(IdempotentPayload):
    plan_tier: str
    quantity: int = Field(ge=1, le=4)
    frequency: str
    product_option: str


class ReschedulePayload(IdempotentPayload):
    delivery_date: str


class LoginPayload(BaseModel):
    email: str
    password: str


class RegistrationStartPayload(BaseModel):
    display_name: str
    email: str
    password: str
    terms: str


class CodePayload(BaseModel):
    code: str


class RecoveryStartPayload(BaseModel):
    email: str


class RecoveryCompletePayload(BaseModel):
    code: str
    new_password: str


class ContactPayload(BaseModel):
    topic: str
    message: str
    idempotency_key: str


@app.get("/healthz")
def healthz() -> dict[str, object]:
    backend, _, _ = services()
    return {
        "ok": True,
        "site_id": SITE_ID,
        "database": backend.lifecycle.health()["status"],
        "payment_adapter": backend.config.payments["default_adapter"],
        "remote_runtime_requests": "forbidden",
    }


@app.get("/", response_class=HTMLResponse)
def home(request: Request) -> HTMLResponse:
    return page(request, ui.home)


@app.get("/shop", response_class=HTMLResponse)
def shop(
    request: Request,
    q: str = "",
    category: str = "",
    concern: str = "",
    sort: str = "featured",
) -> HTMLResponse:
    return page(request, ui.shop, q[:120], category[:40], concern[:40], sort[:40])


@app.get("/shop/{slug}", response_class=HTMLResponse)
def shop_product_detail(request: Request, slug: str) -> HTMLResponse:
    if slug not in ui.PRODUCT_BY_SLUG:
        return page(request, ui.not_found, request.url.path, status_code=404)
    return page(request, ui.product_detail, slug)


@app.get("/products/custom-formula-acne/", response_class=HTMLResponse)
def formula(request: Request) -> HTMLResponse:
    return page(request, ui.formula)


@app.get("/products/{slug}/", response_class=HTMLResponse)
def product_detail(request: Request, slug: str) -> HTMLResponse:
    if slug not in ui.PRODUCT_BY_SLUG:
        return page(request, ui.not_found, request.url.path, status_code=404)
    return page(request, ui.product_detail, slug)


@app.get("/sign-up/start/face", response_class=HTMLResponse)
def quiz_welcome(request: Request) -> HTMLResponse:
    return page(request, ui.quiz_welcome)


@app.get("/quiz/questionnaire/{step}", response_class=HTMLResponse)
def questionnaire(request: Request, step: str) -> HTMLResponse:
    if step not in ui.QUESTION_COPY:
        return page(request, ui.not_found, request.url.path, status_code=404)
    context = Context(request)
    state = context.store.state(context.actor.owner)
    response = HTMLResponse(ui.questionnaire(context.account, state, step))
    context.apply_cookie(response)
    return response


@app.get("/plans", response_class=HTMLResponse)
def plans(request: Request) -> HTMLResponse:
    context = Context(request)
    response = HTMLResponse(
        ui.plans(context.account, context.store.state(context.actor.owner))
    )
    context.apply_cookie(response)
    return response


@app.get("/checkout/shipping", response_class=HTMLResponse)
def checkout_shipping(request: Request) -> HTMLResponse:
    context = Context(request)
    response = HTMLResponse(
        ui.shipping(context.account, context.store.state(context.actor.owner))
    )
    context.apply_cookie(response)
    return response


@app.get("/checkout/payment", response_class=HTMLResponse)
def checkout_payment(request: Request) -> HTMLResponse:
    context = Context(request)
    response = HTMLResponse(
        ui.payment(context.account, context.store.state(context.actor.owner))
    )
    context.apply_cookie(response)
    return response


@app.get("/checkout/review", response_class=HTMLResponse)
def checkout_review(request: Request) -> HTMLResponse:
    context = Context(request)
    response = HTMLResponse(
        ui.review(context.account, context.store.state(context.actor.owner))
    )
    context.apply_cookie(response)
    return response


@app.get("/auth/login", response_class=HTMLResponse)
def login_page(
    request: Request, email: str = "", next: str = "/account"
) -> HTMLResponse:
    return page(request, ui.login, email[:254], safe_next(next))


@app.get("/auth/register", response_class=HTMLResponse)
def register_page(request: Request) -> HTMLResponse:
    return page(request, ui.register, safe_next(request.query_params.get("next", "/account")))


@app.get("/auth/recover", response_class=HTMLResponse)
def recover_page(request: Request) -> HTMLResponse:
    return page(request, ui.recovery)


@app.get("/account", response_class=HTMLResponse)
def account_page(request: Request) -> Any:
    context, redirect = require_account_page(request, "/account")
    if redirect:
        return redirect
    response = HTMLResponse(
        ui.account_dashboard(
            context.account or {},
            context.store.dashboard(context.actor.owner),
            context.store.state(context.actor.owner),
        )
    )
    context.apply_cookie(response)
    return response


@app.get("/account/address", response_class=HTMLResponse)
def account_address_page(request: Request) -> Any:
    context, redirect = require_account_page(request, "/account/address")
    if redirect:
        return redirect
    response = HTMLResponse(
        ui.account_address(
            context.account or {}, context.store.state(context.actor.owner)
        )
    )
    context.apply_cookie(response)
    return response


@app.get("/account/subscription", response_class=HTMLResponse)
def subscription_page(request: Request) -> Any:
    context, redirect = require_account_page(request, "/account/subscription")
    if redirect:
        return redirect
    response = HTMLResponse(
        ui.subscription(
            context.account or {}, context.store.dashboard(context.actor.owner)
        )
    )
    context.apply_cookie(response)
    return response


@app.get("/account/orders", response_class=HTMLResponse)
def orders_page(request: Request) -> Any:
    context, redirect = require_account_page(request, "/account/orders")
    if redirect:
        return redirect
    response = HTMLResponse(
        ui.orders(context.account or {}, context.store.dashboard(context.actor.owner))
    )
    context.apply_cookie(response)
    return response


@app.get("/account/orders/{order_id}", response_class=HTMLResponse)
def order_detail_page(request: Request, order_id: str) -> Any:
    context, redirect = require_account_page(request, f"/account/orders/{order_id}")
    if redirect:
        return redirect
    data = context.store.dashboard(context.actor.owner)
    item = next(
        (order for order in data["orders"] if order["order_id"] == order_id),
        None,
    )
    if item is None:
        return page(request, ui.not_found, request.url.path, status_code=404)
    response = HTMLResponse(ui.order_detail(context.account or {}, item))
    context.apply_cookie(response)
    return response


@app.get("/help", response_class=HTMLResponse)
def help_page(request: Request, q: str = "") -> HTMLResponse:
    return page(request, ui.help_page)


@app.get("/skincare-101", response_class=HTMLResponse)
def skincare_101_page(
    request: Request, topic: str = "", q: str = ""
) -> HTMLResponse:
    return page(request, ui.skincare_101, topic[:40], q[:120])


@app.get("/skincare-101/articles/{slug}", response_class=HTMLResponse)
def skincare_article_page(request: Request, slug: str) -> HTMLResponse:
    response = page(request, ui.skincare_article, slug)
    if slug not in {item[4] for item in ui.ARTICLES}:
        response.status_code = 404
    return response


@app.get("/contact", response_class=HTMLResponse)
def contact_page(request: Request) -> HTMLResponse:
    return page(request, ui.contact_page)


@app.get("/why-curology", response_class=HTMLResponse)
def why_page(request: Request) -> HTMLResponse:
    return page(request, ui.why_curology)


@app.get("/reviews", response_class=HTMLResponse)
def reviews_page(request: Request) -> HTMLResponse:
    return page(request, ui.reviews_page)


@app.get("/skincare/reviews/", response_class=HTMLResponse)
def reviews_source_path(request: Request) -> HTMLResponse:
    return page(request, ui.reviews_page)


@app.get("/about/{slug}", response_class=HTMLResponse)
def about_page(request: Request, slug: str) -> HTMLResponse:
    pages = {
        "careers": ("Careers", "Explore how teams build accessible, personalized skincare experiences."),
        "press": ("Press room", "Find local background on Curology's personalized skincare model and public milestones."),
    }
    if slug not in pages:
        return page(request, ui.not_found, request.url.path, status_code=404)
    title, copy = pages[slug]
    return page(request, ui.simple_page, title, copy)


@app.get("/terms", response_class=HTMLResponse)
def terms_page(request: Request) -> HTMLResponse:
    return page(
        request,
        ui.simple_page,
        "Terms of Service",
        "Use only synthetic information. Local activation has no relationship to a real Curology subscription.",
    )


@app.get("/privacy", response_class=HTMLResponse)
def privacy_page(request: Request) -> HTMLResponse:
    return page(request, ui.privacy_page)


@app.post("/api/questionnaire/{step}")
def answer_question(
    request: Request, step: str, payload: AnswerPayload
) -> JSONResponse:
    context = Context(request)
    dimensions = {
        "skin-type": "skin_type",
        "acne": "acne_concern",
        "aging": "aging_concern",
    }
    if step not in dimensions:
        return api_response(context, {"detail": "Question not found."}, status_code=404)
    try:
        value = context.store.answer(
            context.actor.owner,
            dimension=dimensions[step],
            value=payload.value,
            idempotency_key=payload.idempotency_key,
        )
        return api_response(context, value)
    except CurologyValidationError as exc:
        return api_error(context, exc)


@app.post("/api/plan")
def choose_plan(request: Request, payload: PlanPayload) -> JSONResponse:
    context = Context(request)
    try:
        return api_response(
            context,
            context.store.select_plan(
                context.actor.owner,
                plan_tier=payload.plan_tier,
                quantity=payload.quantity,
                frequency=payload.frequency,
                product_option=payload.product_option,
                idempotency_key=payload.idempotency_key,
            ),
        )
    except CurologyValidationError as exc:
        return api_error(context, exc)


@app.post("/api/shipping")
def save_shipping(request: Request, payload: ShippingPayload) -> JSONResponse:
    context = Context(request)
    try:
        return api_response(
            context,
            context.store.save_shipping(
                context.actor.owner,
                fields={
                    "name": payload.name,
                    "address": payload.address,
                    "city": payload.city,
                    "region": payload.region,
                    "postal": payload.postal,
                    "email": payload.email,
                },
                idempotency_key=payload.idempotency_key,
            ),
        )
    except CurologyValidationError as exc:
        return api_error(context, exc)


@app.post("/api/payment")
def simulate_payment(request: Request, payload: PaymentPayload) -> JSONResponse:
    context = Context(request)
    try:
        result = context.store.attempt_payment(
            context.actor.owner,
            scenario_id=payload.scenario_id,
            fingerprint=payload.fingerprint,
            idempotency_key=payload.idempotency_key,
        )
        code = 200 if result["ok"] else 409
        result["detail"] = {
            "DECLINED": "The simulated payment was declined. Choose approval or retry.",
            "RETRYABLE": "The simulated payment is retryable. Try again with a new attempt.",
        }.get(str(result["status"]), "Saved local payment simulation.")
        return api_response(context, result, status_code=code)
    except (CurologyValidationError, PaymentError) as exc:
        return api_error(context, exc)


@app.post("/api/activate")
def activate(request: Request, payload: IdempotentPayload) -> JSONResponse:
    context = Context(request)
    try:
        return api_response(
            context,
            context.store.activate(
                context.actor, idempotency_key=payload.idempotency_key
            ),
        )
    except CurologyPermissionError as exc:
        return api_error(context, exc, status_code=403)
    except (CurologyValidationError, CurologyTransitionError, PaymentError) as exc:
        return api_error(context, exc, status_code=409)


@app.post("/api/auth/login")
def sign_in(request: Request, payload: LoginPayload) -> JSONResponse:
    context = Context(request)
    try:
        result = context.auth.sign_in(
            context.token,
            email=payload.email,
            password=payload.password,
            session_rotation_callback=context.store.rotate_actor_state,
        )
        context.set_token(str(result["session_token"]))
        return api_response(context, {"ok": True, "account": result["account"]})
    except AuthError:
        return api_response(
            context, {"detail": "Email or password is incorrect."}, status_code=401
        )


@app.post("/api/auth/logout")
def sign_out(request: Request) -> JSONResponse:
    context = Context(request)
    context.auth.sign_out(context.token)
    new_token, _ = context.auth.ensure_session(None)
    context.set_token(new_token)
    return api_response(context, {"ok": True, "message": "Logged out locally."})


@app.post("/api/auth/register/start")
def registration_start(
    request: Request, payload: RegistrationStartPayload
) -> JSONResponse:
    context = Context(request)
    if payload.terms != "accepted":
        return api_response(
            context, {"detail": "Accept the local terms to continue."}, status_code=400
        )
    try:
        context.auth.start_registration(
            context.token,
            email=payload.email,
            display_name=payload.display_name,
            password=payload.password,
        )
        message = context.auth.local_mail_for_session(
            context.token, purpose="registration"
        )
        return api_response(
            context,
            {
                "ok": True,
                "message": "Saved to the local outbox. No email was sent.",
                "mail_status": "LOCAL_ONLY",
                "local_preview_code": message["verification_code"] if message else None,
            },
        )
    except AuthError as exc:
        return api_error(context, exc, status_code=409)


@app.post("/api/auth/register/verify")
def registration_verify(request: Request, payload: CodePayload) -> JSONResponse:
    context = Context(request)
    try:
        context.auth.verify_registration_code(context.token, payload.code)
        result = context.auth.complete_registration(
            context.token,
            session_rotation_callback=context.store.rotate_actor_state,
        )
        context.set_token(str(result["session_token"]))
        return api_response(context, {"ok": True, "account": result["account"]})
    except AuthError as exc:
        return api_error(context, exc, status_code=400)


@app.post("/api/auth/recovery/start")
def recovery_start(
    request: Request, payload: RecoveryStartPayload
) -> JSONResponse:
    context = Context(request)
    try:
        result = context.auth.start_password_reset(context.token, email=payload.email)
        message = context.auth.local_mail_for_session(
            context.token, purpose="password-reset"
        )
        return api_response(
            context,
            {
                "ok": True,
                "message": result["message"],
                "mail_status": "LOCAL_ONLY" if message else "NOT_CREATED",
                "local_preview_code": message["verification_code"] if message else None,
            },
        )
    except AuthError as exc:
        return api_error(context, exc, status_code=400)


@app.post("/api/auth/recovery/complete")
def recovery_complete(
    request: Request, payload: RecoveryCompletePayload
) -> JSONResponse:
    context = Context(request)
    try:
        context.auth.verify_password_reset_code(context.token, payload.code)
        new_token = context.auth.complete_password_reset(
            context.token,
            new_password=payload.new_password,
            session_rotation_callback=context.store.rotate_actor_state,
        )
        context.set_token(new_token)
        return api_response(context, {"ok": True, "message": "Password updated locally."})
    except AuthError as exc:
        return api_error(context, exc, status_code=400)


def manage_response(
    request: Request,
    action: str,
    payload: IdempotentPayload,
    values: dict[str, Any] | None = None,
) -> JSONResponse:
    context = Context(request)
    try:
        return api_response(
            context,
            context.store.manage(
                context.actor,
                action=action,
                idempotency_key=payload.idempotency_key,
                values=values,
            ),
        )
    except CurologyPermissionError as exc:
        return api_error(context, exc, status_code=403)
    except (CurologyValidationError, CurologyTransitionError) as exc:
        return api_error(context, exc, status_code=409)


@app.post("/api/subscription/modify")
def modify_subscription(request: Request, payload: ModifyPayload) -> JSONResponse:
    return manage_response(
        request,
        "modify",
        payload,
        {
            "plan_tier": payload.plan_tier,
            "quantity": payload.quantity,
            "frequency": payload.frequency,
            "product_option": payload.product_option,
        },
    )


@app.post("/api/subscription/pause")
def pause_subscription(request: Request, payload: IdempotentPayload) -> JSONResponse:
    return manage_response(request, "pause", payload)


@app.post("/api/subscription/skip")
def skip_subscription(request: Request, payload: IdempotentPayload) -> JSONResponse:
    return manage_response(request, "skip", payload)


@app.post("/api/subscription/reschedule")
def reschedule_subscription(
    request: Request, payload: ReschedulePayload
) -> JSONResponse:
    return manage_response(
        request, "reschedule", payload, {"delivery_date": payload.delivery_date}
    )


@app.post("/api/subscription/cancel")
def cancel_subscription(request: Request, payload: IdempotentPayload) -> JSONResponse:
    return manage_response(request, "cancel", payload)


@app.post("/api/subscription/reactivate")
def reactivate_subscription(
    request: Request, payload: IdempotentPayload
) -> JSONResponse:
    return manage_response(request, "reactivate", payload)


@app.post("/api/contact")
def save_contact(request: Request, payload: ContactPayload) -> JSONResponse:
    context = Context(request)
    try:
        return api_response(
            context,
            context.store.contact(
                context.actor.owner,
                topic=payload.topic,
                message=payload.message,
                idempotency_key=payload.idempotency_key,
            ),
        )
    except CurologyValidationError as exc:
        return api_error(context, exc)


@app.get("/{path:path}", response_class=HTMLResponse)
def unknown(request: Request, path: str) -> HTMLResponse:
    return page(request, ui.not_found, request.url.path, status_code=404)