from fastapi import APIRouter, Form, HTTPException, Request
from fastapi.responses import HTMLResponse
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, UserRepository
from app.sync.manager import SyncAlreadyRunning
from app.web.routes import templates

router = APIRouter()

APP_VERSION = "1.0.0"


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)
    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.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()
    return templates.TemplateResponse(
        request, "fragments/sync_result.html", {"outcomes": [_normalize_outcome(o) for o in outcomes]}
    )


@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
    return templates.TemplateResponse(request, "system.html", {
        "csrf_token": ensure_csrf_token(request),
        "app_version": APP_VERSION,
        "sync_interval_minutes": settings.sync_interval_minutes,
        "last_tick": scheduler.last_tick,
        "next_tick": scheduler.next_tick,
        "user_count": user_count,
        "activity_count": activity_count,
    })