from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session, joinedload
from typing import List
import database
import models
import schemas
from datetime import datetime

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

def get_current_timestamp():
    return datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%fZ')

@router.post("/", response_model=schemas.Workout)
def create_workout(workout: schemas.WorkoutCreate, db: Session = Depends(database.get_db)):
    # Проверяем уникальность sync_id
    db_workout = db.query(models.Workout).filter(models.Workout.sync_id == workout.sync_id).first()
    if db_workout:
        raise HTTPException(status_code=400, detail="Workout with this sync_id already exists")

    timestamp = get_current_timestamp()
    db_workout = models.Workout(
        sync_id=workout.sync_id,
        client_id=workout.client_id,
        workout_type_id=workout.workout_type_id,
        start_time=workout.start_time,
        end_time=workout.end_time,
        notes=workout.notes,
        created_at=timestamp,
        updated_at=timestamp
    )
    db.add(db_workout)
    db.flush()  # Получаем ID

    # Добавляем упражнения
    for we_data in workout.workout_exercises or []:
        db_we = models.WorkoutExercise(
            sync_id=we_data.sync_id,
            workout_id=db_workout.id,
            exercise_id=we_data.exercise_id,
            exercise_name=we_data.exercise_name,
            sort_order=we_data.sort_order,
            created_at=timestamp
        )
        db.add(db_we)
        db.flush()

        # Добавляем подходы
        for set_data in we_data.sets or []:
            db_set = models.Set(
                sync_id=set_data.sync_id,
                workout_exercise_id=db_we.id,
                is_dropset=set_data.is_dropset,
                weight=set_data.weight,
                reps=set_data.reps,
                rating=set_data.rating,
                notes=set_data.notes,
                sort_order=set_data.sort_order,
                timestamp=set_data.timestamp,
                created_at=timestamp
            )
            db.add(db_set)
            db.flush()

            # Добавляем элементы дроп-сета
            if set_data.is_dropset:
                for item_data in set_data.dropset_items or []:
                    db_item = models.DropsetItem(
                        set_id=db_set.id,
                        weight=item_data.weight,
                        reps=item_data.reps,
                        sort_order=item_data.sort_order
                    )
                    db.add(db_item)

    # Добавляем кардио
    for cardio_data in workout.cardio_sessions or []:
        db_cardio = models.Cardio(
            sync_id=cardio_data.sync_id,
            workout_id=db_workout.id,
            cardio_type=cardio_data.cardio_type,
            purpose=cardio_data.purpose,
            duration=cardio_data.duration,
            distance=cardio_data.distance,
            speed=cardio_data.speed,
            incline=cardio_data.incline,
            resistance=cardio_data.resistance,
            notes=cardio_data.notes,
            sort_order=cardio_data.sort_order,
            created_at=timestamp
        )
        db.add(db_cardio)

    db.commit()
    db.refresh(db_workout)
    return db_workout

@router.get("/", response_model=List[schemas.Workout])
def list_workouts(
    client_id: int = None,
    skip: int = 0,
    limit: int = 100,
    db: Session = Depends(database.get_db)
):
    query = db.query(models.Workout).options(
        joinedload(models.Workout.workout_exercises)
        .joinedload(models.WorkoutExercise.sets)
        .joinedload(models.Set.dropset_items),
        joinedload(models.Workout.cardio_sessions)
    )

    if client_id:
        query = query.filter(models.Workout.client_id == client_id)

    return query.order_by(models.Workout.start_time.desc()).offset(skip).limit(limit).all()

@router.get("/{workout_id}", response_model=schemas.Workout)
def get_workout(workout_id: int, db: Session = Depends(database.get_db)):
    db_workout = db.query(models.Workout).options(
        joinedload(models.Workout.workout_exercises)
        .joinedload(models.WorkoutExercise.sets)
        .joinedload(models.Set.dropset_items),
        joinedload(models.Workout.cardio_sessions)
    ).filter(models.Workout.id == workout_id).first()

    if not db_workout:
        raise HTTPException(status_code=404, detail="Workout not found")
    return db_workout

@router.put("/{workout_id}", response_model=schemas.Workout)
def update_workout(workout_id: int, workout: schemas.WorkoutUpdate, db: Session = Depends(database.get_db)):
    db_workout = db.query(models.Workout).filter(models.Workout.id == workout_id).first()
    if not db_workout:
        raise HTTPException(status_code=404, detail="Workout not found")

    update_data = workout.dict(exclude_unset=True)
    for key, value in update_data.items():
        setattr(db_workout, key, value)

    db_workout.updated_at = get_current_timestamp()
    db.commit()
    db.refresh(db_workout)
    return db_workout

@router.delete("/{workout_id}")
def delete_workout(workout_id: int, db: Session = Depends(database.get_db)):
    db_workout = db.query(models.Workout).filter(models.Workout.id == workout_id).first()
    if not db_workout:
        raise HTTPException(status_code=404, detail="Workout not found")
    db.delete(db_workout)
    db.commit()
    return {"status": "deleted"}