"""EveryDollar source-grounded, zero-remote-runtime offline clone."""

from __future__ import annotations

import hmac
import html
import os
from pathlib import Path
from typing import Any, Callable

from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse, JSONResponse, Response
from starlette.staticfiles import StaticFiles

from backend import store
from websitebench.local_clone_auth import AuthError


SITE_ID = "everydollar"
ROOT = Path(__file__).resolve().parent
STATIC = ROOT / "static"
INDEX = ROOT / "frontend" / "index.html"
ADMIN_TOKEN = os.environ.get("WEBSITEBENCH_EVERYDOLLAR_ADMIN_TOKEN", "everydollar-local-reset-token")
KNOWN_PATHS = {
    "/", "/money/everydollar", "/app", "/app/", "/app/budget", "/app/transactions",
    "/app/goals", "/app/insights", "/app/settings", "/app/help", "/app/sign-in",
    "/app/roadmap", "/app/paycheck-planning", "/app/localproviders", "/app/learn",
    "/app/coaching", "/app/my-feed", "/app/sign-out",
    "/app/sign-up", "/app/forgot-password",
    "/company/terms-of-use", "/company/privacy-policy",
}

app = FastAPI(title="EveryDollar offline clone", docs_url=None, redoc_url=None, openapi_url=None)
app.mount("/static", StaticFiles(directory=str(STATIC)), name="static")

CONTENT_SECURITY_POLICY = (
    "default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; "
    "script-src 'self'; connect-src 'self'; font-src 'self' data:; frame-ancestors 'none'; "
    "base-uri 'self'; form-action 'self'"
)


@app.middleware("http")
async def security_headers(request: Request, call_next: Callable[..., Any]):
    response = await call_next(request)
    response.headers["Content-Security-Policy"] = CONTENT_SECURITY_POLICY
    response.headers["Referrer-Policy"] = "no-referrer"
    response.headers["X-Content-Type-Options"] = "nosniff"
    response.headers["X-Frame-Options"] = "DENY"
    return response


def _cookies(request: Request) -> tuple[str, str, dict[str, Any]]:
    actor = request.cookies.get("wb_everydollar_actor") or store.new_actor()
    token, session = store.ensure_auth_session(request.cookies.get("wb_everydollar_auth"))
    return actor, token, session


def _attach(response: Response, request: Request, actor: str, token: str) -> Response:
    secure = request.url.scheme == "https"
    response.set_cookie("wb_everydollar_actor", actor, httponly=True, samesite="lax", secure=secure, max_age=2592000)
    response.set_cookie("wb_everydollar_auth", token, httponly=True, samesite="lax", secure=secure, max_age=2592000)
    return response


def _json(payload: Any, request: Request, actor: str, token: str, status: int = 200) -> JSONResponse:
    return _attach(JSONResponse(payload, status_code=status), request, actor, token)


async def _body(request: Request) -> dict[str, Any]:
    try:
        value = await request.json()
    except Exception:
        return {}
    return value if isinstance(value, dict) else {}


def _account(session: dict[str, Any]) -> dict[str, Any] | None:
    value = session.get("account")
    return value if isinstance(value, dict) else None


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


@app.post("/__admin/reset", include_in_schema=False)
async def admin_reset(request: Request) -> JSONResponse:
    if not hmac.compare_digest(request.headers.get("X-WebsiteBench-Admin-Token", ""), ADMIN_TOKEN):
        return JSONResponse({"error": "forbidden"}, status_code=403)
    store.reset()
    return JSONResponse({"reset": True, "site_id": SITE_ID})


@app.get("/api/bootstrap", include_in_schema=False)
async def bootstrap(request: Request, month: str | None = None) -> JSONResponse:
    actor, token, session = _cookies(request)
    try:
        payload = store.snapshot(actor, _account(session), month)
    except ValueError as exc:
        return _json({"error": str(exc)}, request, actor, token, 422)
    return _json(payload, request, actor, token)


@app.post("/api/budget/items", include_in_schema=False)
async def add_item(request: Request) -> JSONResponse:
    actor, token, session = _cookies(request)
    try:
        value = store.add_item(actor, _account(session), await _body(request))
    except (ValueError, TypeError) as exc:
        return _json({"error": str(exc)}, request, actor, token, 422)
    return _json(value, request, actor, token, 201)


@app.patch("/api/budget/items/{item_id}", include_in_schema=False)
async def update_item(item_id: str, request: Request) -> JSONResponse:
    actor, token, session = _cookies(request)
    try:
        value = store.update_item(actor, _account(session), item_id, await _body(request))
    except PermissionError as exc:
        return _json({"error": str(exc)}, request, actor, token, 404)
    except (ValueError, TypeError) as exc:
        return _json({"error": str(exc)}, request, actor, token, 422)
    return _json(value, request, actor, token)


@app.delete("/api/budget/items/{item_id}", include_in_schema=False)
async def delete_item(item_id: str, request: Request) -> JSONResponse:
    actor, token, session = _cookies(request)
    try:
        value = store.delete_item(actor, _account(session), item_id)
    except PermissionError as exc:
        return _json({"error": str(exc)}, request, actor, token, 404)
    return _json(value, request, actor, token)


@app.post("/api/budget/items/{item_id}/move", include_in_schema=False)
async def move_item(item_id: str, request: Request) -> JSONResponse:
    actor, token, session = _cookies(request)
    body = await _body(request)
    try:
        value = store.move_item(actor, _account(session), item_id, str(body.get("direction", "")))
    except PermissionError as exc:
        return _json({"error": str(exc)}, request, actor, token, 404)
    except ValueError as exc:
        return _json({"error": str(exc)}, request, actor, token, 422)
    return _json(value, request, actor, token)


@app.post("/api/transactions", include_in_schema=False)
async def add_transaction(request: Request) -> JSONResponse:
    actor, token, session = _cookies(request)
    try:
        value = store.add_transaction(actor, _account(session), await _body(request))
    except PermissionError as exc:
        return _json({"error": str(exc)}, request, actor, token, 403)
    except (ValueError, TypeError) as exc:
        return _json({"error": str(exc)}, request, actor, token, 422)
    return _json(value, request, actor, token, 201)


@app.delete("/api/transactions/{transaction_id}", include_in_schema=False)
async def delete_transaction(transaction_id: str, request: Request) -> JSONResponse:
    actor, token, session = _cookies(request)
    try:
        value = store.delete_transaction(actor, _account(session), transaction_id)
    except PermissionError as exc:
        return _json({"error": str(exc)}, request, actor, token, 404)
    return _json(value, request, actor, token)


@app.patch("/api/transactions/{transaction_id}", include_in_schema=False)
async def update_transaction(transaction_id: str, request: Request) -> JSONResponse:
    actor, token, session = _cookies(request)
    try:
        value = store.update_transaction(actor, _account(session), transaction_id, await _body(request))
    except PermissionError as exc:
        return _json({"error": str(exc)}, request, actor, token, 404)
    except (ValueError, TypeError) as exc:
        return _json({"error": str(exc)}, request, actor, token, 422)
    return _json(value, request, actor, token)


@app.post("/api/months/copy", include_in_schema=False)
async def copy_month(request: Request) -> JSONResponse:
    actor, token, session = _cookies(request)
    body = await _body(request)
    try:
        value = store.copy_month(actor, _account(session), str(body.get("source", "")), str(body.get("target", "")))
    except ValueError as exc:
        return _json({"error": str(exc)}, request, actor, token, 422)
    return _json(value, request, actor, token, 201)


@app.post("/api/goals", include_in_schema=False)
async def add_goal(request: Request) -> JSONResponse:
    actor, token, session = _cookies(request)
    try:
        value = store.save_goal(actor, _account(session), await _body(request))
    except (ValueError, TypeError) as exc:
        return _json({"error": str(exc)}, request, actor, token, 422)
    return _json(value, request, actor, token, 201)


@app.patch("/api/goals/{goal_id}", include_in_schema=False)
async def update_goal(goal_id: str, request: Request) -> JSONResponse:
    actor, token, session = _cookies(request)
    try:
        value = store.update_goal(actor, _account(session), goal_id, await _body(request))
    except PermissionError as exc:
        return _json({"error": str(exc)}, request, actor, token, 404)
    except (ValueError, TypeError) as exc:
        return _json({"error": str(exc)}, request, actor, token, 422)
    return _json(value, request, actor, token)


@app.post("/api/preferences", include_in_schema=False)
async def preferences(request: Request) -> JSONResponse:
    actor, token, session = _cookies(request)
    value = store.save_preferences(actor, _account(session), await _body(request))
    return _json(value, request, actor, token)


@app.post("/api/auth/register", include_in_schema=False)
async def register(request: Request) -> JSONResponse:
    actor, token, _ = _cookies(request)
    body = await _body(request)
    try:
        created = store.register(str(body.get("email", "")), str(body.get("display_name", "")), str(body.get("password", "")))
        signed = store.sign_in(token, str(body.get("email", "")), str(body.get("password", "")))
        store.transfer_budget(actor, created["subject_id"])
    except (AuthError, ValueError) as exc:
        return _json({"error": str(exc)}, request, actor, token, 422)
    return _json({"account": signed["account"], "verification": "Local demo account verified without external email."}, request, actor, signed["session_token"], 201)


@app.post("/api/auth/login", include_in_schema=False)
async def login(request: Request) -> JSONResponse:
    actor, token, _ = _cookies(request)
    body = await _body(request)
    try:
        signed = store.sign_in(token, str(body.get("email", "")), str(body.get("password", "")))
        store.transfer_budget(actor, signed["account"]["subject_id"])
    except AuthError:
        return _json({"error": "Email or password is incorrect."}, request, actor, token, 401)
    return _json({"account": signed["account"]}, request, actor, signed["session_token"])


@app.post("/api/auth/logout", include_in_schema=False)
async def logout(request: Request) -> JSONResponse:
    actor, token, _ = _cookies(request)
    store.sign_out(token)
    new_token, _ = store.ensure_auth_session(None)
    return _json({"signed_out": True}, request, actor, new_token)


@app.post("/api/auth/recovery-preview", include_in_schema=False)
async def recovery_preview(request: Request) -> JSONResponse:
    actor, token, _ = _cookies(request)
    email_address = str((await _body(request)).get("email", "")).strip()
    if not email_address or "@" not in email_address:
        return _json({"error": "Enter a valid email address."}, request, actor, token, 422)
    return _json({"sent": False, "message": "No email was sent. This offline preview shows the recovery flow without external effects."}, request, actor, token)


@app.get("/{path:path}", include_in_schema=False)
async def page(path: str, request: Request) -> HTMLResponse:
    pathname = "/" + path
    status = 200 if pathname in KNOWN_PATHS else 404
    body = INDEX.read_text(encoding="utf-8")
    route_marker = html.escape(pathname, quote=True)
    body = body.replace("<body>", f'<body data-route="{route_marker}"><p hidden data-route-announcer>EveryDollar route {route_marker}</p>', 1)
    return HTMLResponse(body, status_code=status)