import asyncio
import json
import logging
import math
import os
import threading
import uuid
from datetime import datetime, timezone
from pathlib import Path
from xml.etree import ElementTree as ET

from fastapi import Depends, FastAPI, HTTPException, Query, Request
from fastapi.responses import StreamingResponse
from fastapi.staticfiles import StaticFiles
from garminconnect import Garmin, GarminConnectAuthenticationError
from openai import OpenAI
from sqlalchemy import and_, select
from sqlalchemy.orm import Session
from starlette.middleware.sessions import SessionMiddleware

from auth import require_user, router as auth_router
from db import Insight, Ride, User, create_tables, engine
from storage import download_gpx, upload_gpx

logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
    datefmt="%H:%M:%S",
)
for _noisy in ("httpx", "httpcore", "openai"):
    logging.getLogger(_noisy).setLevel(logging.WARNING)
log = logging.getLogger("bikeslop")

LLAMACPP_BASE_URL = os.getenv("LLAMACPP_BASE_URL", "http://localhost:8080/v1")
SECRET_KEY = os.getenv("SECRET_KEY", "dev-secret-change-me")
MODEL_NAME = "local-model"

app = FastAPI()
app.add_middleware(SessionMiddleware, secret_key=SECRET_KEY)
app.include_router(auth_router)

_mfa_sessions: dict[str, dict] = {}
_user_rides_cache: dict[str, dict[str, dict]] = {}
_points_cache: dict[str, list[dict]] = {}
_POINTS_CACHE_MAX = 50

# ---------------------------------------------------------------------------
# GPX parsing helpers
# ---------------------------------------------------------------------------

NS = {
    "gpx": "http://www.topografix.com/GPX/1/1",
    "ns3": "http://www.garmin.com/xmlschemas/TrackPointExtension/v1",
}


def haversine(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
    R = 6_371_000
    phi1, phi2 = math.radians(lat1), math.radians(lat2)
    dphi = math.radians(lat2 - lat1)
    dlambda = math.radians(lon2 - lon1)
    a = math.sin(dphi / 2) ** 2 + math.cos(phi1) * math.cos(phi2) * math.sin(dlambda / 2) ** 2
    return 2 * R * math.asin(math.sqrt(a))


def parse_gpx_bytes(data: bytes, filename: str) -> dict:
    """Parse GPX bytes into a ride dict including 'points'. No 'id' field."""
    root = ET.fromstring(data)

    name_el = root.find(".//gpx:trk/gpx:name", NS)
    stem = Path(filename).stem
    name = name_el.text if name_el is not None else stem
    type_el = root.find(".//gpx:trk/gpx:type", NS)
    activity_type = type_el.text if type_el is not None else "cycling"

    points = []
    for pt in root.findall(".//gpx:trkpt", NS):
        lat = float(pt.get("lat"))
        lon = float(pt.get("lon"))
        ele_el = pt.find("gpx:ele", NS)
        ele = float(ele_el.text) if ele_el is not None else 0.0
        time_el = pt.find("gpx:time", NS)
        ts = None
        if time_el is not None:
            ts = datetime.fromisoformat(time_el.text.replace("Z", "+00:00"))
        hr_el = pt.find(".//ns3:hr", NS)
        hr = int(hr_el.text) if hr_el is not None else None
        points.append({"lat": lat, "lon": lon, "ele": ele, "time": ts, "hr": hr})

    distance_m = 0.0
    ele_gain = 0.0
    ele_loss = 0.0
    for i in range(1, len(points)):
        p0, p1 = points[i - 1], points[i]
        distance_m += haversine(p0["lat"], p0["lon"], p1["lat"], p1["lon"])
        de = p1["ele"] - p0["ele"]
        if de > 0:
            ele_gain += de
        else:
            ele_loss += abs(de)

    duration_s = 0
    start_time = None
    end_time = None
    if points and points[0]["time"] and points[-1]["time"]:
        start_time = points[0]["time"]
        end_time = points[-1]["time"]
        duration_s = int((end_time - start_time).total_seconds())

    hrs = [p["hr"] for p in points if p["hr"] is not None]
    avg_hr = round(sum(hrs) / len(hrs)) if hrs else None
    max_hr = max(hrs) if hrs else None
    avg_speed_kmh = (distance_m / 1000) / (duration_s / 3600) if duration_s > 0 else 0

    zone_counts = {"z1": 0, "z2": 0, "z3": 0, "z4": 0, "z5": 0}
    for h in hrs:
        if h < 120:
            zone_counts["z1"] += 1
        elif h < 140:
            zone_counts["z2"] += 1
        elif h < 160:
            zone_counts["z3"] += 1
        elif h < 180:
            zone_counts["z4"] += 1
        else:
            zone_counts["z5"] += 1
    total_hr_pts = len(hrs)
    hr_zones = {
        k: round(v / total_hr_pts * 100, 1) if total_hr_pts else 0
        for k, v in zone_counts.items()
    }

    return {
        "name": name,
        "activity_type": activity_type,
        "filename": filename,
        "start_time": start_time.isoformat() if start_time else None,
        "end_time": end_time.isoformat() if end_time else None,
        "duration_s": duration_s,
        "distance_m": round(distance_m),
        "distance_km": round(distance_m / 1000, 2),
        "avg_speed_kmh": round(avg_speed_kmh, 1),
        "elevation_gain_m": round(ele_gain),
        "elevation_loss_m": round(ele_loss),
        "avg_hr": avg_hr,
        "max_hr": max_hr,
        "hr_zones": hr_zones,
        "has_gps": len(points) > 0 and points[0].get("lat") is not None,
        "points": [
            {
                "lat": p["lat"],
                "lon": p["lon"],
                "ele": round(p["ele"], 1),
                "time": p["time"].isoformat() if p["time"] else None,
                "hr": p["hr"],
            }
            for p in points
        ],
    }


# ---------------------------------------------------------------------------
# Per-user ride + points cache
# ---------------------------------------------------------------------------


def _load_user_rides(user_id: str) -> dict[str, dict]:
    with Session(engine) as s:
        rows = s.query(Ride).filter_by(user_id=user_id).all()
        return {r.id: r.to_dict() for r in rows}


def get_user_rides_cached(user_id: str) -> dict[str, dict]:
    if user_id not in _user_rides_cache:
        _user_rides_cache[user_id] = _load_user_rides(user_id)
    return _user_rides_cache[user_id]


def invalidate_user_cache(user_id: str) -> None:
    _user_rides_cache.pop(user_id, None)


def _fetch_ride_points(ride_id: str, s3_key: str) -> list[dict]:
    if ride_id not in _points_cache:
        if len(_points_cache) >= _POINTS_CACHE_MAX:
            del _points_cache[next(iter(_points_cache))]
        gpx_data = download_gpx(s3_key)
        parsed = parse_gpx_bytes(gpx_data, s3_key.split("/")[-1])
        _points_cache[ride_id] = parsed["points"]
    return _points_cache[ride_id]


def _get_ride_insight(ride_id: str) -> str | None:
    with Session(engine) as s:
        row = s.query(Insight).filter_by(ride_id=ride_id).first()
        return row.text if row else None


def _save_ride_insight(ride_id: str, user_id: str, text: str) -> None:
    with Session(engine) as s:
        row = s.query(Insight).filter_by(ride_id=ride_id).first()
        if row:
            row.text = text
        else:
            row = Insight(ride_id=ride_id, user_id=user_id, text=text)
            s.add(row)
        s.commit()


# ---------------------------------------------------------------------------
# Startup
# ---------------------------------------------------------------------------


@app.on_event("startup")
def startup():
    global MODEL_NAME
    create_tables()
    log.info("Database tables ready.")

    try:
        client = OpenAI(base_url=LLAMACPP_BASE_URL, api_key="not-needed")
        models = client.models.list()
        first = next(iter(models), None)
        if first:
            MODEL_NAME = first.id
            log.info("Discovered model: %s", MODEL_NAME)
        else:
            log.warning("No models from %s — using fallback '%s'", LLAMACPP_BASE_URL, MODEL_NAME)
    except Exception as exc:
        log.warning("Could not reach llamacpp at %s (%s) — using fallback '%s'", LLAMACPP_BASE_URL, exc, MODEL_NAME)


# ---------------------------------------------------------------------------
# API endpoints
# ---------------------------------------------------------------------------


@app.get("/api/me")
def get_me(user: User = Depends(require_user)):
    return {"display_name": user.display_name, "email": user.email}


@app.get("/api/rides")
def list_rides(user: User = Depends(require_user)):
    summary_keys = [
        "id", "name", "activity_type", "start_time", "duration_s",
        "distance_km", "avg_speed_kmh", "elevation_gain_m",
        "avg_hr", "max_hr", "has_gps",
    ]
    rides_map = get_user_rides_cached(user.id)
    rides = [{k: r[k] for k in summary_keys} for r in rides_map.values()]
    rides.sort(key=lambda x: x["start_time"] or "", reverse=True)
    return rides


@app.get("/api/rides/{ride_id}")
def get_ride(ride_id: str, user: User = Depends(require_user)):
    rides_map = get_user_rides_cached(user.id)
    if ride_id not in rides_map:
        raise HTTPException(status_code=404, detail="Ride not found")
    r = {k: v for k, v in rides_map[ride_id].items() if k != "points"}
    r["cached_insight"] = _get_ride_insight(ride_id)
    return r


@app.get("/api/rides/{ride_id}/points")
def get_ride_points(ride_id: str, user: User = Depends(require_user)):
    rides_map = get_user_rides_cached(user.id)
    if ride_id not in rides_map:
        raise HTTPException(status_code=404, detail="Ride not found")
    return _fetch_ride_points(ride_id, rides_map[ride_id]["s3_key"])


def _karvonen_zones(rhr: int, max_hr: int, points: list[dict]) -> dict:
    hrr = max_hr - rhr
    bounds = [rhr + p * hrr for p in (0.50, 0.60, 0.70, 0.80)]
    labels = [
        f"Z1 <{round(bounds[0])}bpm",
        f"Z2 {round(bounds[0])}–{round(bounds[1])}bpm",
        f"Z3 {round(bounds[1])}–{round(bounds[2])}bpm",
        f"Z4 {round(bounds[2])}–{round(bounds[3])}bpm",
        f"Z5 >{round(bounds[3])}bpm",
    ]
    hrs = [p["hr"] for p in points if p.get("hr") is not None]
    if not hrs:
        return {label: 0 for label in labels}
    counts = [0] * 5
    for h in hrs:
        if h < bounds[0]: counts[0] += 1
        elif h < bounds[1]: counts[1] += 1
        elif h < bounds[2]: counts[2] += 1
        elif h < bounds[3]: counts[3] += 1
        else: counts[4] += 1
    return {labels[i]: round(counts[i] / len(hrs) * 100, 1) for i in range(5)}


def _llm_client() -> OpenAI:
    return OpenAI(base_url=LLAMACPP_BASE_URL, api_key="not-needed")


def _get_previous_insight_for_user(ride: dict, user_id: str) -> str | None:
    ride_time = ride.get("start_time")
    if not ride_time:
        return None
    with Session(engine) as s:
        row = s.execute(
            select(Insight.text)
            .join(Ride, Insight.ride_id == Ride.id)
            .where(and_(
                Ride.user_id == user_id,
                Ride.start_time < ride_time,
                Ride.has_gps == True,
                Ride.distance_km > 0,
            ))
            .order_by(Ride.start_time.desc())
            .limit(1)
        ).first()
        return row[0] if row else None


def _build_prompt(ride: dict, user_id: str, rhr: int, global_max_hr: int, points: list[dict]) -> str:
    ride_time = ride["start_time"]
    rides_map = get_user_rides_cached(user_id)
    gps_rides = [r for r in rides_map.values() if r["has_gps"] and r["distance_km"] > 0 and r["start_time"]]
    past_rides = [r for r in gps_rides if r["start_time"] < ride_time]

    zones = _karvonen_zones(rhr, global_max_hr, points)
    zone_str = ", ".join(f"{k}={v}%" for k, v in zones.items())
    duration_min = ride["duration_s"] // 60
    ride_date = ride_time[:10] if ride_time else "unknown"

    if past_rides:
        avg_dist = sum(r["distance_km"] for r in past_rides) / len(past_rides)
        hr_list = [r["avg_hr"] for r in past_rides if r["avg_hr"]]
        avg_hr_val = sum(hr_list) / len(hr_list) if hr_list else 0
        history_str = f"Before today they've completed {len(past_rides)} rides, averaging {avg_dist:.1f} km and {avg_hr_val:.0f} bpm."
    else:
        history_str = "This is one of their earliest recorded rides — no prior history to compare against."

    previous_insight = _get_previous_insight_for_user(ride, user_id)
    if previous_insight:
        prior_section = f"""
Your feedback from their last ride:
---
{previous_insight}
---

Based on that advice, briefly note (in one sentence woven naturally into your response) whether today's data suggests they followed it or not. Do not lecture about it — just one honest observation."""
    else:
        prior_section = ""

    return f"""You are a friendly cycling coach giving post-ride feedback. You are writing this on {ride_date}, the day of the ride. Do not plan, outline, or show any reasoning — just write the response directly.

Today's ride: {duration_min} min, {ride["distance_km"]} km, {ride["avg_speed_kmh"]} km/h, {ride["elevation_gain_m"]} m elevation. Avg HR {ride["avg_hr"]}, max {ride["max_hr"]}, resting HR {rhr} bpm (lifetime max {global_max_hr}). Time in zones: {zone_str}.

Athlete history (as of {ride_date}): {history_str}{prior_section}

Your response must begin with exactly one line in this format:
TITLE: <a funny, punchy title for this specific ride in 4–8 words>

Then one blank line, then write exactly 3–4 short paragraphs in a warm, direct "you/your" voice: effort level, what the zones reveal about the session type, how it compares to their history so far, one concrete suggestion. No bullet points, no headers, no preamble. Begin writing now."""


@app.post("/api/rides/{ride_id}/insights")
def post_insights(ride_id: str, user: User = Depends(require_user), rhr: int = Query(60, ge=30, le=100)):
    rides_map = get_user_rides_cached(user.id)
    if ride_id not in rides_map:
        raise HTTPException(status_code=404, detail="Ride not found")
    ride = rides_map[ride_id]

    gps_rides = [r for r in rides_map.values() if r["has_gps"] and r["distance_km"] > 0]
    global_max_hr = max((r["max_hr"] or 0 for r in gps_rides), default=200)
    points = _fetch_ride_points(ride_id, ride["s3_key"])
    prompt = _build_prompt(ride, user.id, rhr, global_max_hr, points)

    client = _llm_client()
    log.info("POST /insights ride_id=%s rhr=%d user=%s", ride_id, rhr, user.id)
    log.debug("Prompt:\n%s", prompt)

    def stream_response():
        accumulated = []
        try:
            log.info("Opening stream...")
            stream = client.chat.completions.create(
                model=MODEL_NAME,
                messages=[{"role": "user", "content": prompt}],
                stream=True,
                max_tokens=600,
                extra_body={"chat_template_kwargs": {"enable_thinking": False}},
            )
            chunks_received = 0
            for chunk in stream:
                chunks_received += 1
                if chunks_received <= 3:
                    log.debug("Chunk #%d raw: %s", chunks_received, chunk.model_dump())
                d = chunk.choices[0].delta.model_dump()
                delta = d.get("content") or d.get("reasoning_content")
                if delta:
                    accumulated.append(delta)
                    yield delta
            log.info("Stream complete — %d chunks, %d chars", chunks_received, sum(len(c) for c in accumulated))
            _save_ride_insight(ride_id, user.id, "".join(accumulated))
            log.info("Saved insight for %s", ride_id)
        except Exception as exc:
            log.exception("Error streaming insights: %s", exc)
            yield f"\n\n[Error: {exc}]"

    return StreamingResponse(stream_response(), media_type="text/plain")


@app.post("/api/insights/generate-all")
def generate_all_insights(user: User = Depends(require_user), rhr: int = Query(60, ge=30, le=100)):
    rides_map = get_user_rides_cached(user.id)
    gps_rides = [r for r in rides_map.values() if r["has_gps"] and r["distance_km"] > 0 and r["start_time"]]
    global_max_hr = max((r["max_hr"] or 0 for r in gps_rides), default=200)
    ordered = sorted(gps_rides, key=lambda r: r["start_time"])

    with Session(engine) as s:
        insighted_ids = {
            row[0] for row in s.execute(
                select(Insight.ride_id).where(Insight.user_id == user.id)
            )
        }
    to_generate = [r for r in ordered if r["id"] not in insighted_ids]
    total = len(to_generate)
    log.info("generate-all: %d rides to generate (rhr=%d user=%s)", total, rhr, user.id)

    def sse_stream():
        llm = _llm_client()
        for idx, ride in enumerate(to_generate, 1):
            ride_id = ride["id"]
            yield f"data: {json.dumps({'index': idx, 'total': total, 'ride_id': ride_id, 'status': 'generating'})}\n\n"
            log.info("Generating insight %d/%d: %s", idx, total, ride_id)
            try:
                points = _fetch_ride_points(ride_id, ride["s3_key"])
                prompt = _build_prompt(ride, user.id, rhr, global_max_hr, points)
                response = llm.chat.completions.create(
                    model=MODEL_NAME,
                    messages=[{"role": "user", "content": prompt}],
                    stream=False,
                    max_tokens=600,
                    extra_body={"chat_template_kwargs": {"enable_thinking": False}},
                )
                msg = response.choices[0].message.model_dump()
                text = msg.get("content") or msg.get("reasoning_content") or ""
                _save_ride_insight(ride_id, user.id, text)
                yield f"data: {json.dumps({'index': idx, 'total': total, 'ride_id': ride_id, 'status': 'done'})}\n\n"
            except Exception as exc:
                log.exception("Failed insight for %s: %s", ride_id, exc)
                yield f"data: {json.dumps({'index': idx, 'total': total, 'ride_id': ride_id, 'status': 'error', 'error': str(exc)})}\n\n"
        yield f"data: {json.dumps({'status': 'complete', 'total': total})}\n\n"

    return StreamingResponse(sse_stream(), media_type="text/event-stream")


# ---------------------------------------------------------------------------
# Garmin Connect sync
# ---------------------------------------------------------------------------


@app.post("/api/fetch-rides")
async def fetch_rides_from_garmin(request: Request, user: User = Depends(require_user)):
    body = await request.json()
    email = body.get("email", "")
    password = body.get("password", "")
    user_id = user.id

    session_id = uuid.uuid4().hex
    queue: asyncio.Queue = asyncio.Queue()
    loop = asyncio.get_running_loop()
    mfa_event = threading.Event()
    _mfa_sessions[session_id] = {"event": mfa_event, "code": None}

    def emit(evt):
        loop.call_soon_threadsafe(queue.put_nowait, evt)

    def prompt_mfa():
        emit({"status": "mfa_required", "session_id": session_id})
        mfa_event.wait(timeout=120)
        return _mfa_sessions.get(session_id, {}).get("code") or ""

    def garmin_worker():
        try:
            emit({"status": "auth"})
            garmin = Garmin(email=email, password=password, prompt_mfa=prompt_mfa)
            garmin.login()

            emit({"status": "fetching"})
            activities = garmin.get_activities(0, 50)
            cycling = [
                a for a in activities
                if "cycling" in a.get("activityType", {}).get("typeKey", "")
            ]

            with Session(engine) as s:
                existing_filenames = {
                    row[0] for row in s.execute(
                        select(Ride.filename).where(Ride.user_id == user_id)
                    )
                }

            to_download = []
            for act in cycling:
                act_id = act["activityId"]
                start = act.get("startTimeLocal", "")
                name = act.get("activityName", "activity")
                safe_time = start.replace(":", "-").replace(" ", "_")
                safe_name = "".join(c for c in name if c.isalnum() or c in (" ", "_", "-")).strip()
                filename = f"{safe_time}_{safe_name}_{act_id}.gpx"
                if filename not in existing_filenames:
                    to_download.append((act_id, name, filename))

            skipped = len(cycling) - len(to_download)
            added = 0
            for idx, (act_id, name, filename) in enumerate(to_download, 1):
                emit({"status": "downloading", "index": idx, "total": len(to_download), "name": name})
                try:
                    gpx_data = garmin.download_activity(act_id, dl_fmt=garmin.ActivityDownloadFormat.GPX)
                    s3_key = upload_gpx(user_id, filename, gpx_data)
                    parsed = parse_gpx_bytes(gpx_data, filename)
                    ride_id = uuid.uuid4().hex
                    with Session(engine) as s:
                        s.add(Ride(
                            id=ride_id,
                            user_id=user_id,
                            s3_key=s3_key,
                            filename=filename,
                            name=parsed["name"],
                            activity_type=parsed["activity_type"],
                            start_time=parsed["start_time"],
                            end_time=parsed["end_time"],
                            duration_s=parsed["duration_s"],
                            distance_m=parsed["distance_m"],
                            distance_km=parsed["distance_km"],
                            avg_speed_kmh=parsed["avg_speed_kmh"],
                            elevation_gain_m=parsed["elevation_gain_m"],
                            elevation_loss_m=parsed["elevation_loss_m"],
                            avg_hr=parsed["avg_hr"],
                            max_hr=parsed["max_hr"],
                            hr_zones_json=json.dumps(parsed["hr_zones"]),
                            has_gps=parsed["has_gps"],
                        ))
                        s.commit()
                    _points_cache[ride_id] = parsed["points"]
                    invalidate_user_cache(user_id)
                    added += 1
                except Exception as exc:
                    log.error("Failed to download activity %s: %s", act_id, exc)

            emit({"status": "complete", "added": added, "skipped": skipped})
        except GarminConnectAuthenticationError:
            emit({"status": "error", "message": "Login failed. Check your email and password."})
        except Exception as exc:
            log.exception("fetch-rides error: %s", exc)
            emit({"status": "error", "message": str(exc)})
        finally:
            _mfa_sessions.pop(session_id, None)
            emit(None)

    async def generate():
        loop.run_in_executor(None, garmin_worker)
        while True:
            evt = await queue.get()
            if evt is None:
                break
            yield f"data: {json.dumps(evt)}\n\n"

    return StreamingResponse(generate(), media_type="text/event-stream")


@app.post("/api/mfa")
async def submit_mfa(request: Request):
    body = await request.json()
    session_id = body.get("session_id", "")
    code = body.get("code", "")
    session = _mfa_sessions.get(session_id)
    if not session:
        raise HTTPException(status_code=404, detail="Session not found or expired")
    session["code"] = code
    session["event"].set()
    return {"ok": True}


# ---------------------------------------------------------------------------
# Serve frontend
# ---------------------------------------------------------------------------

static_dir = Path(__file__).parent / "static"
static_dir.mkdir(exist_ok=True)
app.mount("/", StaticFiles(directory=static_dir, html=True), name="static")