screen-locker/screen_locker/_manual_workout.py

"""Manual (unverified) workout rate-limiting, validation, and entry-building.

Pure logic — no Tk imports. Unlike sick days, manual-workout entries live
directly in ``workout_log.json`` (not a separate history file): a manual
entry is just another ``workout_data`` dict with ``type="manual_workout"``,
so ``LogMixin.save_workout_log`` already HMAC-signs it for free and the
weekly-minimum/bonus logic already counts it once wired into
``COUNTED_WORKOUT_TYPES``. This module only adds the rate-budget check (by
scanning ``workout_log.json`` itself) and the evidence-form validation.

Each sport has its own structured fields (e.g. table tennis tracks
matches/sets won-lost and racket/balls, rather than one free-text blob) —
see :class:`ManualWorkoutDraft` and :data:`SPORT_CHOICES`.
"""

from __future__ import annotations

from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
import json
import logging
from typing import TYPE_CHECKING, Any

from screen_locker._constants import (
    MANUAL_WORKOUT_BUDGET_PER_7_DAYS,
    MANUAL_WORKOUT_BUDGET_PER_30_DAYS,
    MANUAL_WORKOUT_DESCRIPTION_MIN_CHARS,
    MANUAL_WORKOUT_MIN_DURATION_MINUTES,
    MANUAL_WORKOUT_REFLECTION_MIN_CHARS,
    MANUAL_WORKOUT_RPE_MAX,
    MANUAL_WORKOUT_RPE_MIN,
)

if TYPE_CHECKING:
    from pathlib import Path

_logger = logging.getLogger(__name__)

MANUAL_WORKOUT_TYPE = "manual_workout"

SPORT_TABLE_TENNIS = "table_tennis"
SPORT_OTHER = "other"
SPORT_CHOICES: tuple[str, ...] = (SPORT_TABLE_TENNIS, SPORT_OTHER)
SPORT_LABELS: dict[str, str] = {
    SPORT_TABLE_TENNIS: "Table tennis",
    SPORT_OTHER: "Other",
}


def _today_iso() -> str:
    """Return today's date as ``YYYY-MM-DD`` (UTC)."""
    return datetime.now(tz=timezone.utc).strftime("%Y-%m-%d")


def _parse_iso(date_str: str) -> datetime | None:
    """Parse ``YYYY-MM-DD`` into a UTC datetime, or return None."""
    try:
        return datetime.strptime(date_str, "%Y-%m-%d").replace(tzinfo=timezone.utc)
    except ValueError:
        return None


def _load_logs(log_file: Path) -> dict[str, Any]:
    """Read ``workout_log.json``. Missing or unreadable file yields ``{}``."""
    if not log_file.exists():
        return {}
    try:
        with log_file.open() as f:
            return json.load(f)
    except (OSError, json.JSONDecodeError):
        _logger.warning("Could not read workout log for manual-workout budget check")
        return {}


def count_in_window(
    log_file: Path,
    days: int,
    *,
    today: str | None = None,
) -> int:
    """Return how many ``manual_workout`` entries fall in the trailing window."""
    today_str = today or _today_iso()
    today_dt = _parse_iso(today_str)
    if today_dt is None:
        return 0
    cutoff = today_dt - timedelta(days=days)
    logs = _load_logs(log_file)
    count = 0
    for date_str, entry in logs.items():
        parsed = _parse_iso(date_str)
        if parsed is None or not (cutoff < parsed <= today_dt):
            continue
        workout_data = entry.get("workout_data", {}) if isinstance(entry, dict) else {}
        if workout_data.get("type") == MANUAL_WORKOUT_TYPE:
            count += 1
    return count


def is_budget_exhausted(
    log_file: Path,
    *,
    today: str | None = None,
) -> bool:
    """Return True if either rolling window has reached its manual-workout budget."""
    return (
        count_in_window(log_file, 7, today=today) >= MANUAL_WORKOUT_BUDGET_PER_7_DAYS
        or count_in_window(log_file, 30, today=today)
        >= MANUAL_WORKOUT_BUDGET_PER_30_DAYS
    )


def budget_summary(
    log_file: Path,
    *,
    today: str | None = None,
) -> str:
    """One-line UI summary string for the manual-workout budget."""
    week = count_in_window(log_file, 7, today=today)
    month = count_in_window(log_file, 30, today=today)
    return (
        f"Manual: {week}/{MANUAL_WORKOUT_BUDGET_PER_7_DAYS}w · "
        f"{month}/{MANUAL_WORKOUT_BUDGET_PER_30_DAYS}m"
    )


@dataclass
class ManualWorkoutDraft:
    """User-supplied evidence fields for a manual (unverified) workout.

    Fields shared by every sport come first (required unless noted).
    Sport-specific fields follow, grouped by which ``sport`` they apply to —
    only the group matching ``sport`` is validated/persisted.
    """

    sport: str
    start_time: str  # "HH:MM"
    end_time: str  # "HH:MM"
    location_name: str
    transport_method: str
    cost: str
    rpe: int
    went_well: str
    to_improve: str
    overall_feeling: str
    location_maps_link: str = ""  # optional — awkward to fill from a locked PC
    reservation_phone: str = ""
    proof_screenshot_path: str = ""  # optional — phone-oriented field
    techniques_practiced: str = ""
    warm_up_minutes: str = ""
    pain_or_injury: str = "none"
    # SPORT_TABLE_TENNIS fields
    matches_won: int = 0
    matches_lost: int = 0
    sets_won: int = 0
    sets_lost: int = 0
    racket: str = ""
    balls: str = ""
    # SPORT_OTHER fields
    activity_type_other: str = ""
    activity_details: str = ""
    equipment: str = ""


def _parse_hhmm(value: str) -> datetime | None:
    """Parse an ``HH:MM`` string into a datetime on an arbitrary fixed date."""
    try:
        return datetime.strptime(value.strip(), "%H:%M").replace(tzinfo=timezone.utc)
    except ValueError:
        return None


def _duration_minutes(draft: ManualWorkoutDraft) -> float | None:
    """Return ``end_time - start_time`` in minutes, or None if unparsable."""
    start = _parse_hhmm(draft.start_time)
    end = _parse_hhmm(draft.end_time)
    if start is None or end is None or end <= start:
        return None
    return (end - start).total_seconds() / 60


def validate_manual_workout(draft: ManualWorkoutDraft) -> str | None:
    """Return an error message if the draft is invalid, else None."""
    if draft.sport not in SPORT_CHOICES:
        return "Please choose a sport"

    required = {
        "Start time": draft.start_time,
        "End time": draft.end_time,
        "Location name": draft.location_name,
        "Transport method": draft.transport_method,
        "Cost": draft.cost,
    }
    for label, value in required.items():
        if not value.strip():
            return f"{label} is required"

    duration = _duration_minutes(draft)
    if duration is None:
        return "Start/end time must be valid HH:MM, with end after start"
    if duration < MANUAL_WORKOUT_MIN_DURATION_MINUTES:
        return (
            f"Session must be at least {MANUAL_WORKOUT_MIN_DURATION_MINUTES} "
            f"minutes (currently {duration:.0f})"
        )

    if not MANUAL_WORKOUT_RPE_MIN <= draft.rpe <= MANUAL_WORKOUT_RPE_MAX:
        return (
            f"RPE must be between {MANUAL_WORKOUT_RPE_MIN} and {MANUAL_WORKOUT_RPE_MAX}"
        )

    if draft.sport == SPORT_TABLE_TENNIS:
        error = _validate_table_tennis(draft)
    else:
        error = _validate_other_sport(draft)
    if error is not None:
        return error

    for label, value in (
        ("What went well", draft.went_well),
        ("What to improve", draft.to_improve),
        ("Overall feeling", draft.overall_feeling),
    ):
        if len(value.strip()) < MANUAL_WORKOUT_REFLECTION_MIN_CHARS:
            return (
                f"{label} must be at least {MANUAL_WORKOUT_REFLECTION_MIN_CHARS} "
                f"characters (currently {len(value.strip())})"
            )

    return None


def _validate_table_tennis(draft: ManualWorkoutDraft) -> str | None:
    """Validate the table-tennis-specific fields of a draft."""
    for label, value in (
        ("Matches won", draft.matches_won),
        ("Matches lost", draft.matches_lost),
        ("Sets won", draft.sets_won),
        ("Sets lost", draft.sets_lost),
    ):
        if value < 0:
            return f"{label} cannot be negative"
    if draft.matches_won + draft.matches_lost == 0:
        return "Enter at least one match played (won + lost)"
    if not draft.racket.strip():
        return "Racket is required"
    if not draft.balls.strip():
        return "Balls are required"
    return None


def _validate_other_sport(draft: ManualWorkoutDraft) -> str | None:
    """Validate the generic "other sport" fields of a draft."""
    if not draft.activity_type_other.strip():
        return "Activity type is required"
    if len(draft.activity_details.strip()) < MANUAL_WORKOUT_DESCRIPTION_MIN_CHARS:
        return (
            "What was done must be at least "
            f"{MANUAL_WORKOUT_DESCRIPTION_MIN_CHARS} characters "
            f"(currently {len(draft.activity_details.strip())})"
        )
    return None


def build_entry(draft: ManualWorkoutDraft) -> dict[str, object]:
    """Convert a validated draft into a ``workout_data`` dict for the log."""
    duration = _duration_minutes(draft)
    if draft.sport == SPORT_TABLE_TENNIS:
        activity_label = "table tennis"
    else:
        activity_label = draft.activity_type_other.strip()

    entry: dict[str, object] = {
        "type": MANUAL_WORKOUT_TYPE,
        "source": f"{activity_label} at {draft.location_name.strip()}",
        "sport": draft.sport,
        "activity_type": activity_label,
        "start_time": draft.start_time.strip(),
        "end_time": draft.end_time.strip(),
        "duration_minutes": f"{duration:.1f}" if duration is not None else "",
        "location_name": draft.location_name.strip(),
        "location_maps_link": draft.location_maps_link.strip(),
        "transport_method": draft.transport_method.strip(),
        "cost": draft.cost.strip(),
        "reservation_phone": draft.reservation_phone.strip(),
        "proof_screenshot_path": draft.proof_screenshot_path.strip(),
        "rpe": int(draft.rpe),
        "techniques_practiced": draft.techniques_practiced.strip(),
        "warm_up_minutes": draft.warm_up_minutes.strip(),
        "pain_or_injury": draft.pain_or_injury.strip(),
        "went_well": draft.went_well.strip(),
        "to_improve": draft.to_improve.strip(),
        "overall_feeling": draft.overall_feeling.strip(),
    }
    if draft.sport == SPORT_TABLE_TENNIS:
        entry.update(
            {
                "matches_won": int(draft.matches_won),
                "matches_lost": int(draft.matches_lost),
                "sets_won": int(draft.sets_won),
                "sets_lost": int(draft.sets_lost),
                "racket": draft.racket.strip(),
                "balls": draft.balls.strip(),
            }
        )
    else:
        entry.update(
            {
                "activity_details": draft.activity_details.strip(),
                "equipment": draft.equipment.strip(),
            }
        )
    return entry