#!/usr/bin/env python3
"""VitalTrends weekly training review.

Builds a Markdown summary of the last 7 days of training from the VitalTrends
REST API: volume by muscle group, every Training Log session with its
exercises, and the heaviest set per exercise. With --prs it also checks each
exercise's history and marks new heaviest loads.

Read-only: this script only sends GET requests to VitalTrends. It never prints
or logs your API key. Not medical advice.

Requirements: Python 3.9+ and the `requests` package (pip install requests).

Environment variables:
  VITALTRENDS_API_KEY    Required. Your key from https://vitaltrends.net/developer
  VITALTRENDS_TIMEZONE   Optional IANA timezone, e.g. Europe/Lisbon. Use the
                         same timezone as your VitalTrends profile. Defaults to
                         this computer's local timezone.
  VITALTRENDS_API_BASE   Optional. Defaults to https://vitaltrends.net/api/v1

Usage:
  python3 weekly-training-review.py                  # print Markdown
  python3 weekly-training-review.py --prs            # also flag new heaviest loads
  python3 weekly-training-review.py -o review.md     # write to a file
"""

import argparse
import os
import sys
from datetime import datetime, time, timedelta
from urllib.parse import quote, urlsplit

try:
    from zoneinfo import ZoneInfo
except ImportError:  # pragma: no cover
    sys.exit("Python 3.9 or newer is required.")

try:
    import requests
except ImportError:
    sys.exit("This script needs the requests package: pip install requests")

API_BASE = os.environ.get("VITALTRENDS_API_BASE", "https://vitaltrends.net/api/v1").rstrip("/")
USER_AGENT = "vitaltrends-automation-template/1.0"
MAX_PR_LOOKUPS = 25  # keeps --prs well inside the 120 requests per minute limit


class ApiError(Exception):
    """A VitalTrends API error that should stop the script."""


def local_timezone():
    tz_name = os.environ.get("VITALTRENDS_TIMEZONE", "").strip()
    if tz_name:
        return ZoneInfo(tz_name)
    return datetime.now().astimezone().tzinfo


def api_session(api_key):
    session = requests.Session()
    session.headers.update({
        "Authorization": f"Bearer {api_key}",
        "Accept": "application/json",
        "User-Agent": USER_AGENT,
    })
    return session


def get_json(session, path, params=None, allow_404=False):
    url = path if path.startswith("https://") else f"{API_BASE}{path}"
    # Only ever send the API key to the VitalTrends API host.
    if urlsplit(url).netloc != urlsplit(API_BASE).netloc:
        raise ApiError("Refusing to follow a link outside the VitalTrends API.")
    try:
        response = session.get(url, params=params, timeout=30)
    except requests.RequestException as exc:
        raise ApiError(f"Could not reach VitalTrends: {exc.__class__.__name__}") from None
    if response.status_code == 404 and allow_404:
        return None
    if response.status_code == 401:
        raise ApiError("VitalTrends rejected the API key (401). Check VITALTRENDS_API_KEY.")
    if response.status_code == 403:
        raise ApiError("VitalTrends refused the request (403). API access needs an active subscription.")
    if response.status_code == 429:
        retry = response.headers.get("Retry-After", "60")
        raise ApiError(f"Rate limit reached (429). Try again in {retry} seconds.")
    if response.status_code >= 400:
        raise ApiError(f"VitalTrends returned HTTP {response.status_code} for {urlsplit(url).path}.")
    return response.json()


def get_all(session, path, params, max_pages=10):
    """Follow links.next on paginated list endpoints."""
    rows, url, query = [], path, dict(params)
    for _ in range(max_pages):
        body = get_json(session, url, query)
        rows.extend(body.get("data") or [])
        next_url = (body.get("links") or {}).get("next")
        if not next_url:
            break
        url, query = next_url, None
    return rows


def kg(value):
    return f"{value:,.0f} kg" if value is not None else "n/a"


def best_set(exercise):
    """Heaviest set (by weight, then reps) for one exercise, or None for bodyweight/timed work."""
    weighted = [s for s in exercise.get("sets") or [] if s.get("weight_kg") is not None]
    if not weighted:
        return None
    return max(weighted, key=lambda s: (s["weight_kg"], s.get("reps") or 0))


def previous_max_load(session, exercise_key, before):
    """Heaviest load in sessions that started before `before`, from the exercise history."""
    body = get_json(session, f"/training/exercises/{quote(exercise_key, safe='')}", allow_404=True)
    if not body:
        return None
    sessions = (body.get("data") or {}).get("sessions") or []
    loads = []
    for item in sessions:
        started = item.get("started_at")
        load = item.get("max_load_kg")
        if started is None or load is None:
            continue
        try:
            started_at = datetime.fromisoformat(str(started).replace("Z", "+00:00"))
        except ValueError:
            continue
        if started_at < before:
            loads.append(float(load))
    return max(loads) if loads else None


def build_review(session, today, tz, check_prs):
    start_date = today - timedelta(days=6)
    start_dt = datetime.combine(start_date, time.min, tzinfo=tz)
    # A date-only end means midnight at the start of that day, so send an explicit end of day.
    end_dt = datetime.combine(today, time(23, 59, 59), tzinfo=tz)

    usage = get_json(session, "/training/muscle-groups/usage", {
        "start_date": start_date.isoformat(),
        "end_date": today.isoformat(),
    })
    logs = get_all(session, "/workout-logs", {
        "start": start_dt.isoformat(),
        "end": end_dt.isoformat(),
        "include": "exercises",
        "per_page": 100,
    })
    logs.sort(key=lambda log: log.get("started_at") or "")

    lines = [f"# Training review: {start_date.isoformat()} to {today.isoformat()}", ""]

    if not logs:
        lines += [
            "No Training Log sessions in the last 7 days.",
            "",
            "If you trained, check that Hevy has synced or that the workout was imported into VitalTrends.",
        ]
        return "\n".join(lines) + "\n"

    total_sets = sum(log.get("set_count") or 0 for log in logs)
    total_minutes = sum(log.get("duration_minutes") or 0 for log in logs)
    lines += [
        f"- Sessions: {len(logs)}",
        f"- Sets: {total_sets}",
        f"- Lifted volume: {kg(usage.get('total_amount'))}",
    ]
    if total_minutes:
        lines.append(f"- Recorded training time: {total_minutes:.0f} min")
    lines.append("")

    groups = usage.get("muscle_groups") or []
    if groups:
        lines += ["## Volume by muscle group", "", "| Muscle group | Volume | Share | Sessions |", "|---|---:|---:|---:|"]
        for group in sorted(groups, key=lambda g: g.get("amount") or 0, reverse=True):
            lines.append(
                f"| {group.get('muscle_group')} | {kg(group.get('amount'))} | "
                f"{(group.get('percentage') or 0):.0f}% | {group.get('workout_count') or 0} |"
            )
        lines.append("")

    lines += ["## Sessions", ""]
    heaviest = {}  # exercise_key -> (name, set)
    for log in logs:
        title = log.get("title") or "Strength session"
        when = log.get("local_time") or (log.get("started_at") or "")[:16]
        duration = f", {log['duration_minutes']:.0f} min" if log.get("duration_minutes") else ""
        lines.append(f"### {when}: {title}")
        exercises = log.get("exercise_count") or 0
        sets = log.get("set_count") or 0
        lines.append(f"{exercises} exercise{'' if exercises == 1 else 's'}, {sets} set{'' if sets == 1 else 's'}, "
                     f"{kg(log.get('total_volume_kg'))}{duration} (source: {log.get('source')})")
        lines.append("")
        for exercise in log.get("exercises") or []:
            top = best_set(exercise)
            group = exercise.get("muscle_group") or "Other"
            sets = len(exercise.get("sets") or [])
            top_text = f", top set {top.get('reps') or 0} x {top['weight_kg']:g} kg" if top else ""
            lines.append(f"- {exercise.get('name')} ({group}): {sets} sets{top_text}")
            key = exercise.get("exercise_key")
            if top and key:
                current = heaviest.get(key)
                if current is None or top["weight_kg"] > current[1]["weight_kg"]:
                    heaviest[key] = (exercise.get("name"), top)
        lines.append("")

    if heaviest:
        lines += ["## Heaviest set per exercise", ""]
        lookups = 0
        for key, (name, top) in sorted(heaviest.items(), key=lambda item: item[1][0] or ""):
            marker = ""
            if check_prs and lookups < MAX_PR_LOOKUPS:
                lookups += 1
                previous = previous_max_load(session, key, start_dt)
                if previous is None:
                    marker = " (first logged week)"
                elif top["weight_kg"] > previous:
                    marker = f" (new heaviest load, previous {previous:g} kg)"
            lines.append(f"- {name}: {top.get('reps') or 0} x {top['weight_kg']:g} kg{marker}")
        if check_prs and len(heaviest) > MAX_PR_LOOKUPS:
            lines.append(f"- History checked for the first {MAX_PR_LOOKUPS} exercises only.")
        lines.append("")

    lines.append("_Generated from VitalTrends. Not medical advice._")
    return "\n".join(lines) + "\n"


def main():
    parser = argparse.ArgumentParser(description="Write a Markdown review of the last 7 days of training.")
    parser.add_argument("--prs", action="store_true", help="check exercise history for new heaviest loads")
    parser.add_argument("-o", "--output", help="write the Markdown to this file instead of printing it")
    args = parser.parse_args()

    api_key = os.environ.get("VITALTRENDS_API_KEY", "").strip()
    if not api_key:
        sys.exit("Set VITALTRENDS_API_KEY to your VitalTrends API key (Settings -> Developer).")

    tz = local_timezone()
    today = datetime.now(tz).date()
    try:
        markdown = build_review(api_session(api_key), today, tz, args.prs)
    except ApiError as exc:
        sys.exit(str(exc))

    if args.output:
        with open(args.output, "w", encoding="utf-8") as handle:
            handle.write(markdown)
        print(f"Wrote {args.output}", file=sys.stderr)
    else:
        print(markdown, end="")


if __name__ == "__main__":
    main()
