plm-lottery/app/main.py

import asyncio
import logging
from contextlib import asynccontextmanager
from pathlib import Path

from fastapi import FastAPI, Request, status
from fastapi.responses import FileResponse, JSONResponse
from fastapi.staticfiles import StaticFiles

from app.logging_config import setup_logging

setup_logging()

import app.bets.confirmation  # noqa: F401  (registers the "bet" confirmation handler)
import app.rounds.confirmation  # noqa: F401  (registers the "payout" confirmation handler)
import app.withdrawals.confirmation  # noqa: F401  (registers the "withdrawal" confirmation handler)
from app.api.routes.admin import router as admin_router
from app.api.routes.bets import router as bets_router
from app.api.routes.qr import router as qr_router
from app.api.routes.rounds import router as rounds_router
from app.api.routes.users import router as users_router
from app.api.routes.withdrawals import router as withdrawals_router
from app.auth.routes import router as auth_router
from app.api.errors import ApiError, http_error
from app.config import settings, validate_runtime_secrets
from app.db.base import AsyncSessionLocal
from app.electrum.client import ElectrumClient
from app.electrum.listener import ElectrumListener
from app.rounds.scheduler import RoundScheduler
from app.tx.broadcast import RbfBumper
from app.tx.confirmation import ConfirmationPoller
from app.tx.locks import UserLocks

logger = logging.getLogger(__name__)


def _make_electrum_client() -> ElectrumClient:
    return ElectrumClient(settings.electrum_host, settings.electrum_port, settings.electrum_use_ssl)


@asynccontextmanager
async def lifespan(app: FastAPI):
    listener = ElectrumListener(_make_electrum_client, AsyncSessionLocal)
    app.state.electrum_listener = listener
    app.state.user_locks = UserLocks()

    scheduler = RoundScheduler(AsyncSessionLocal, listener)
    poller = ConfirmationPoller(AsyncSessionLocal, lambda: listener.client)
    bumper = RbfBumper(AsyncSessionLocal, lambda: listener.client)

    tasks = [
        asyncio.create_task(listener.run()),
        asyncio.create_task(scheduler.run()),
        asyncio.create_task(poller.run()),
        asyncio.create_task(bumper.run()),
    ]
    try:
        yield
    finally:
        for task in tasks:
            task.cancel()
        if listener.client is not None:
            await listener.client.close()


app = FastAPI(title="PLM Lottery", lifespan=lifespan)
app.include_router(auth_router)
app.include_router(users_router)
app.include_router(bets_router)
app.include_router(withdrawals_router)
app.include_router(admin_router)
app.include_router(qr_router)
app.include_router(rounds_router)


@app.exception_handler(Exception)
async def log_unhandled_exception(request: Request, exc: Exception) -> JSONResponse:
    logger.exception("Unhandled error on %s %s", request.method, request.url.path)
    return JSONResponse(
        status_code=500,
        content={"detail": ApiError("internal_error", "internal server error").as_detail()},
    )


@app.get("/health")
async def health() -> dict[str, str]:
    return {"status": "ok"}


_NO_STORE_HEADERS = {"Cache-Control": "no-store"}


@app.get("/", include_in_schema=False)
async def index_page() -> FileResponse:
    return FileResponse("app/static/index.html", headers=_NO_STORE_HEADERS)


@app.get("/admin", include_in_schema=False)
async def admin_panel() -> FileResponse:
    return FileResponse("app/static/admin.html", headers=_NO_STORE_HEADERS)


@app.get("/guida", include_in_schema=False)
async def user_guide() -> FileResponse:
    """Serves docs/guida-utente.md as plain text so it opens inline in the
    browser (no markdown rendering — keeps this simple), linked from the
    navbar's help button in app/static/index.html.

    The Dockerfile must COPY docs/ for this to exist inside the container (it
    didn't, which made this a guaranteed 500 in every real deployment — B-16).
    Answers a clean 404 if the file is missing rather than an unhandled error."""
    if not _USER_GUIDE_PATH.is_file():
        logger.error("user guide missing at %s (is docs/ shipped in the image?)", _USER_GUIDE_PATH)
        raise http_error(status.HTTP_404_NOT_FOUND, "guide_unavailable", "user guide not available")
    return FileResponse(_USER_GUIDE_PATH, media_type="text/plain; charset=utf-8")


app.mount("/", StaticFiles(directory="app/static", html=True), name="static")
_USER_GUIDE_PATH = Path("docs/guida-utente.md")