"""Workout day viewer routes.

Displays the warmup routine and main exercises for each workout day,
with the active profile's programming targets.
"""

from datetime import date

import structlog
from fastapi import APIRouter, Depends, Request
from fastapi.responses import HTMLResponse
from sqlmodel import Session, select

from app.database import get_db_session
from app.models.user import User
from app.models.user_exercise_program import UserExerciseProgram
from app.services.exercise_service import ExerciseService
from app.services.log_service import LogService
from app.services.progression_service import ProgressionService
from app.services.workout_session_service import WorkoutSessionService
from app.utils.auth import get_current_admin_user, get_active_profile_id

logger = structlog.get_logger(__name__)

router = APIRouter(prefix="/workouts", tags=["workouts"])


@router.get("", response_class=HTMLResponse)
async def workout_days_list(
    request: Request,
    session: Session = Depends(get_db_session),
    admin: User = Depends(get_current_admin_user),
):
    """List all workout days as clickable cards.

    Args:
        request: The incoming HTTP request.
        session: Database session.
        admin: The authenticated admin user.

    Returns:
        Rendered workout days list page.
    """
    exercise_service = ExerciseService(session)
    days = exercise_service.list_workout_days()

    templates = request.app.state.templates
    return templates.TemplateResponse("pages/workout_days.html", {
        "request": request,
        "days": days,
        "admin": admin,
    })


@router.get("/{day_name}", response_class=HTMLResponse)
async def workout_day_detail(
    day_name: str,
    request: Request,
    session: Session = Depends(get_db_session),
    admin: User = Depends(get_current_admin_user),
):
    """Display a full workout day -- warmups + exercises with form cues.

    Args:
        day_name: The workout day name (e.g., "push", "pull").
        request: The incoming HTTP request.
        session: Database session.
        admin: The authenticated admin user.

    Returns:
        Rendered workout day detail page.
    """
    exercise_service = ExerciseService(session)

    # Normalize day name for DB lookup (e.g., "push" -> "Push", "full-body" -> "Full Body")
    day_display = day_name.replace("-", " ").title()

    warmups = exercise_service.list_warmups()
    exercises = exercise_service.list_exercises(workout_day=day_display)

    # Get active profile's programming if set
    active_profile_id = get_active_profile_id(request)
    programs = {}
    active_profile = None
    existing_logs = {}
    if active_profile_id:
        active_profile = session.get(User, active_profile_id)
        if active_profile:
            statement = select(UserExerciseProgram).where(
                UserExerciseProgram.user_id == active_profile_id
            )
            for prog in session.exec(statement).all():
                programs[prog.exercise_id] = prog

    # Look up the workout day ID for logging forms
    days = exercise_service.list_workout_days()
    workout_day_id = 0
    for d in days:
        if d.name == day_display:
            workout_day_id = d.id
            break

    # Get progression suggestions for each exercise
    suggestions = {}
    if active_profile_id:
        progression = ProgressionService(session)
        for exercise in exercises:
            suggestions[exercise.id] = progression.get_suggestion(
                active_profile_id, exercise.id,
            )

    # Load existing logs for today's session (if any)
    if active_profile_id and workout_day_id:
        ws_service = WorkoutSessionService(session)
        ws = ws_service.get_or_create_session(
            user_id=active_profile_id,
            workout_day_id=workout_day_id,
            session_date=date.today(),
        )
        log_service = LogService(session)
        all_logs = log_service.list_logs_for_session(ws.id)
        for log in all_logs:
            existing_logs.setdefault(log.exercise_id, []).append(log)

    templates = request.app.state.templates
    return templates.TemplateResponse("pages/workout_day.html", {
        "request": request,
        "day_name": day_display,
        "warmups": warmups,
        "exercises": exercises,
        "programs": programs,
        "active_profile": active_profile,
        "existing_logs": existing_logs,
        "suggestions": suggestions,
        "workout_day_id": workout_day_id,
        "admin": admin,
    })