mywhoosh2garmin/app/web/operations.py

from fastapi import APIRouter, Form, HTTPException, Request
from fastapi.responses import HTMLResponse, RedirectResponse
from sqlalchemy import func, select

from app.auth.admin import require_admin
from app.auth.csrf import ensure_csrf_token, validate_csrf
from app.db.models import Activity
from app.db.repositories import ActivityRepository, SchedulerSettingsRepository, SystemLogRepository, UserRepository
from app.sync.manager import SyncAlreadyRunning
from app.web.routes import templates

router = APIRouter()

APP_VERSION = "1.0.0"


def _toast_html(message: str, level: str) -> str:
    return templates.get_template("fragments/toast.html").render(message=message, level=level)


def _outcome_toast(outcome, label: str) -> tuple[str, str]:
    if outcome.status in ("success", "partial"):
        return f"{label}: {outcome.imported} imported, {outcome.failed} failed", "success"
    return f"{label}: sync failed — {outcome.message or 'unknown error'}", "danger"


def _normalize_outcome(item):
    if isinstance(item, Exception):
        return {
            "status": "error",
            "user_id": None,
            "discovered": 0,
            "imported": 0,
            "skipped": 0,
            "failed": 0,
            "message": str(item),
        }
    return {
        "status": item.status,
        "user_id": item.user_id,
        "discovered": item.discovered,
        "imported": item.imported,
        "skipped": item.skipped,
        "failed": item.failed,
        "message": item.message,
    }


@router.post("/users/{user_id}/sync", response_class=HTMLResponse)
async def manual_sync(request: Request, user_id: int, csrf_token: str = Form(...)):
    require_admin(request)
    validate_csrf(request, csrf_token)
    token = ensure_csrf_token(request)
    try:
        outcome = await request.app.state.sync_manager.sync_user(user_id)
        with request.app.state.session_factory() as session:
            row = UserRepository(session).dashboard_row(user_id)
        label = row.name if row is not None else f"Rider #{user_id}"
        message, level = _outcome_toast(outcome, label)
    except SyncAlreadyRunning:
        with request.app.state.session_factory() as session:
            row = UserRepository(session).dashboard_row(user_id)
        label = row.name if row is not None else f"Rider #{user_id}"
        message, level = f"{label}: sync already running", "info"
    row_html = (
        templates.get_template("fragments/user_row.html").render(row=row, csrf_token=token, oob=False)
        if row is not None
        else ""
    )
    return HTMLResponse(row_html + _toast_html(message, level))


@router.post("/sync-all", response_class=HTMLResponse)
async def manual_sync_all(request: Request, csrf_token: str = Form(...)):
    require_admin(request)
    validate_csrf(request, csrf_token)
    outcomes = await request.app.state.sync_manager.sync_all_enabled()
    token = ensure_csrf_token(request)

    parts = [templates.get_template("fragments/sync_all_form.html").render(csrf_token=token)]

    ok = 0
    failed = 0
    with request.app.state.session_factory() as session:
        repository = UserRepository(session)
        for item in outcomes:
            normalized = _normalize_outcome(item)
            if normalized["status"] in ("success", "partial"):
                ok += 1
            else:
                failed += 1
            outcome_user_id = normalized["user_id"]
            if outcome_user_id is not None:
                row = repository.dashboard_row(outcome_user_id)
                if row is not None:
                    parts.append(
                        templates.get_template("fragments/user_row.html").render(row=row, csrf_token=token, oob=True)
                    )

    if not outcomes:
        parts.append(_toast_html("No riders to sync", "info"))
    else:
        level = "success" if failed == 0 else "danger"
        parts.append(_toast_html(f"Synced {len(outcomes)} riders — {ok} ok, {failed} failed", level))

    return HTMLResponse("".join(parts))


@router.post("/users/{user_id}/garmin-mfa", response_class=HTMLResponse)
async def garmin_mfa(request: Request, user_id: int, csrf_token: str = Form(...), code: str = Form(...)):
    require_admin(request)
    validate_csrf(request, csrf_token)
    stripped = code.strip()
    if not stripped or len(stripped) > 20:
        raise HTTPException(status_code=400, detail="Invalid MFA code")
    try:
        outcome = await request.app.state.sync_manager.sync_user(user_id, mfa_code=stripped)
    except SyncAlreadyRunning:
        return HTMLResponse("Sync already running for this user", status_code=409)
    return templates.TemplateResponse(
        request, "fragments/sync_result.html", {"outcomes": [_normalize_outcome(outcome)]}
    )


@router.post("/activities/{activity_id}/retry", response_class=HTMLResponse)
async def retry_activity(request: Request, activity_id: int, csrf_token: str = Form(...)):
    require_admin(request)
    validate_csrf(request, csrf_token)
    with request.app.state.session_factory() as session:
        activity_repo = ActivityRepository(session)
        try:
            activity = activity_repo.reset_retryable_failure(activity_id)
        except ValueError:
            return HTMLResponse("Activity is not retryable", status_code=409)
        user_id = activity.user_id
    try:
        outcome = await request.app.state.sync_manager.sync_user(user_id)
    except SyncAlreadyRunning:
        return HTMLResponse("Sync already running for this user", status_code=409)
    return templates.TemplateResponse(
        request, "fragments/sync_result.html", {"outcomes": [_normalize_outcome(outcome)]}
    )


@router.get("/system", response_class=HTMLResponse)
def system_page(request: Request):
    require_admin(request)
    settings = request.app.state.settings
    scheduler = request.app.state.scheduler
    with request.app.state.session_factory() as session:
        user_count = len(UserRepository(session).list_all())
        activity_count = session.scalar(select(func.count()).select_from(Activity)) or 0
        log_entries = SystemLogRepository(session).list_recent(limit=50)
        scheduler_settings = SchedulerSettingsRepository(session).get_or_create(
            default_minutes=settings.sync_interval_minutes
        )
    return templates.TemplateResponse(request, "system.html", {
        "csrf_token": ensure_csrf_token(request),
        "app_version": APP_VERSION,
        "last_tick": scheduler.last_tick,
        "next_tick": scheduler.next_tick,
        "user_count": user_count,
        "activity_count": activity_count,
        "log_entries": log_entries,
        "scheduler_settings": scheduler_settings,
    })


@router.post("/system/scheduler-settings")
def update_scheduler_settings(
    request: Request,
    csrf_token: str = Form(...),
    day_start_hour: int = Form(...),
    night_start_hour: int = Form(...),
    day_interval_minutes: int = Form(...),
    night_interval_minutes: int = Form(...),
):
    require_admin(request)
    validate_csrf(request, csrf_token)
    if not (0 <= day_start_hour <= 23) or not (0 <= night_start_hour <= 23):
        raise HTTPException(status_code=400, detail="Hours must be between 0 and 23")
    if day_interval_minutes < 1 or night_interval_minutes < 1:
        raise HTTPException(status_code=400, detail="Intervals must be at least 1 minute")
    settings = request.app.state.settings
    with request.app.state.session_factory() as session:
        repository = SchedulerSettingsRepository(session)
        row = repository.get_or_create(default_minutes=settings.sync_interval_minutes)
        repository.update(
            row,
            day_start_hour=day_start_hour,
            night_start_hour=night_start_hour,
            day_interval_minutes=day_interval_minutes,
            night_interval_minutes=night_interval_minutes,
        )
    return RedirectResponse("/system", status_code=303)