banyaro/backend/routes/gassi_zeiten.py

"""BAN YARO — Gassi-Zeiten-Pool (regelmäßige Gassi-Zeiten mit Gleichgesinnten)"""

import json
import logging
from fastapi import APIRouter, Depends, HTTPException
from pydantic import BaseModel, Field
from typing import Optional, List
from database import db
from auth import get_current_user
from math_utils import haversine_m

logger = logging.getLogger(__name__)

router = APIRouter()


class GassiZeitCreate(BaseModel):
    dog_id:     Optional[int]   = None
    wochentage: List[str]                                        # ["mo", "mi", "fr"]
    uhrzeit:    str             = Field(..., max_length=20)      # "17:00"
    ort_name:   Optional[str]   = Field(None, max_length=300)
    lat:        Optional[float] = None
    lon:        Optional[float] = None
    radius_m:   int             = 500
    notiz:      Optional[str]   = Field(None, max_length=2000)


class GassiZeitUpdate(BaseModel):
    aktiv: Optional[int] = None


# ------------------------------------------------------------------
# GET /api/gassi-zeiten — alle in der Nähe (oder eigene)
# ------------------------------------------------------------------
@router.get("")
async def list_gassi_zeiten(
    lat: Optional[float] = None,
    lon: Optional[float] = None,
    radius: int = 5000,       # Meter
    nur_eigene: bool = False,
    user=Depends(get_current_user),
):
    with db() as conn:
        if nur_eigene:
            rows = conn.execute("""
                SELECT gz.*, u.name AS user_name, u.avatar_url,
                       d.name AS dog_name, d.foto_url AS dog_foto_url, d.rasse AS dog_rasse
                FROM gassi_zeiten gz
                LEFT JOIN users u ON u.id = gz.user_id
                LEFT JOIN dogs d ON d.id = gz.dog_id
                WHERE gz.user_id = ?
                ORDER BY gz.uhrzeit ASC
            """, (user["id"],)).fetchall()
        else:
            rows = conn.execute("""
                SELECT gz.*, u.name AS user_name, u.avatar_url,
                       d.name AS dog_name, d.foto_url AS dog_foto_url, d.rasse AS dog_rasse
                FROM gassi_zeiten gz
                LEFT JOIN users u ON u.id = gz.user_id
                LEFT JOIN dogs d ON d.id = gz.dog_id
                WHERE gz.aktiv = 1
                ORDER BY gz.uhrzeit ASC
            """).fetchall()

    result = []
    for r in rows:
        d = dict(r)
        # wochentage JSON parsen
        try:
            d["wochentage"] = json.loads(d["wochentage"]) if isinstance(d["wochentage"], str) else d["wochentage"]
        except Exception:
            d["wochentage"] = []
        d["is_mine"] = (d["user_id"] == user["id"])

        # Distanz-Filter
        if lat is not None and lon is not None and d.get("lat") and d.get("lon"):
            dist = haversine_m(lat, lon, d["lat"], d["lon"])
            if not nur_eigene and dist > radius:
                continue
            d["distance_m"] = int(dist)
        else:
            d["distance_m"] = None

        result.append(d)

    # Sortierung: eigene zuerst, dann nach Distanz
    result.sort(key=lambda x: (0 if x["is_mine"] else 1, x.get("distance_m") or 99999))
    return result


# ------------------------------------------------------------------
# POST /api/gassi-zeiten — eigene Zeit anlegen
# ------------------------------------------------------------------
@router.post("", status_code=201)
async def create_gassi_zeit(data: GassiZeitCreate, user=Depends(get_current_user)):
    if not data.wochentage:
        raise HTTPException(400, "Mindestens ein Wochentag muss angegeben werden.")
    if not data.uhrzeit:
        raise HTTPException(400, "Uhrzeit muss angegeben werden.")

    wochentage_json = json.dumps(data.wochentage)

    with db() as conn:
        # Hund-Prüfung
        if data.dog_id:
            dog = conn.execute(
                "SELECT id FROM dogs WHERE id=? AND user_id=?", (data.dog_id, user["id"])
            ).fetchone()
            if not dog:
                raise HTTPException(403, "Hund nicht gefunden oder gehört nicht dir.")

        cur = conn.execute("""
            INSERT INTO gassi_zeiten (user_id, dog_id, wochentage, uhrzeit,
                                      ort_name, lat, lon, radius_m, notiz)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
        """, (user["id"], data.dog_id, wochentage_json, data.uhrzeit,
              data.ort_name, data.lat, data.lon, data.radius_m, data.notiz))

        row = conn.execute("""
            SELECT gz.*, u.name AS user_name, d.name AS dog_name, d.foto_url AS dog_foto_url
            FROM gassi_zeiten gz
            LEFT JOIN users u ON u.id = gz.user_id
            LEFT JOIN dogs d ON d.id = gz.dog_id
            WHERE gz.id = ?
        """, (cur.lastrowid,)).fetchone()

    result = dict(row)
    try:
        result["wochentage"] = json.loads(result["wochentage"])
    except Exception:
        pass
    result["is_mine"] = True
    return result


# ------------------------------------------------------------------
# PATCH /api/gassi-zeiten/{id} — pausieren / aktivieren
# ------------------------------------------------------------------
@router.patch("/{gz_id}")
async def update_gassi_zeit(gz_id: int, data: GassiZeitUpdate, user=Depends(get_current_user)):
    with db() as conn:
        gz = conn.execute(
            "SELECT * FROM gassi_zeiten WHERE id=?", (gz_id,)
        ).fetchone()
        if not gz:
            raise HTTPException(404, "Gassi-Zeit nicht gefunden.")
        if gz["user_id"] != user["id"]:
            raise HTTPException(403, "Nicht deine Gassi-Zeit.")

        updates = data.model_dump(exclude_none=True)
        if updates:
            cols = ", ".join(f"{k} = ?" for k in updates)
            conn.execute(f"UPDATE gassi_zeiten SET {cols} WHERE id=?", [*updates.values(), gz_id])

        row = conn.execute(
            "SELECT * FROM gassi_zeiten WHERE id=?", (gz_id,)
        ).fetchone()

    result = dict(row)
    try:
        result["wochentage"] = json.loads(result["wochentage"])
    except Exception:
        pass
    result["is_mine"] = True
    return result


# ------------------------------------------------------------------
# DELETE /api/gassi-zeiten/{id}
# ------------------------------------------------------------------
@router.delete("/{gz_id}", status_code=204)
async def delete_gassi_zeit(gz_id: int, user=Depends(get_current_user)):
    with db() as conn:
        gz = conn.execute(
            "SELECT * FROM gassi_zeiten WHERE id=?", (gz_id,)
        ).fetchone()
        if not gz:
            raise HTTPException(404, "Gassi-Zeit nicht gefunden.")
        if gz["user_id"] != user["id"]:
            raise HTTPException(403, "Nicht deine Gassi-Zeit.")
        conn.execute("DELETE FROM gassi_zeiten WHERE id=?", (gz_id,))