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 _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
        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)