"""Plants router — thin sync handlers over services/plants.py.

Routes (all behind the default-deny AuthMiddleware):
- GET    /api/plants/pools                    staging pools + plantings picker
- POST   /api/plants                          create in pool (unplanted/idea)
- GET    /api/plants/{id}                     detail
- PATCH  /api/plants/{id}                     partial update (qty->0 rule)
- DELETE /api/plants/{id}                     delete
- POST   /api/plants/{id}/pool-status         flip idea <-> unplanted
- POST   /api/plants/{id}/mark-planted        pool -> planted (link planting)
- POST   /api/plants/{id}/attach-to-area      layout split/merge attach
- POST   /api/plants/{id}/detach-from-area    back to the pool (+auto-merge)
- POST   /api/plants/{id}/move                move/split between areas

/pools is registered before /{plant_id} so the literal path wins.
"""
from __future__ import annotations

from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session

from ..db import get_db
from ..deps import current_garden_id
from ..schemas.plantings import (
    AttachOut,
    AttachRequest,
    DetachOut,
    MarkPlantedRequest,
    MoveOut,
    MoveRequest,
    OkOut,
    PlantOut,
    PlantUpdate,
    PoolPlantCreate,
    PoolsOut,
    PoolStatusRequest,
)
from ..services import plants as svc

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


@router.get("/pools", response_model=PoolsOut)
def list_pools(
    status: str | None = Query(None, description="unplanted | idea (default: both)"),
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    return svc.list_pools(db, garden_id, status=status)


@router.post("", response_model=PlantOut, status_code=201)
def create_pool_plant(
    payload: PoolPlantCreate,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    result = svc.create_pool_plant(db, garden_id, payload)
    db.commit()
    return result


@router.get("/{plant_id}", response_model=PlantOut)
def get_plant(
    plant_id: int,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    return svc.get_plant(db, garden_id, plant_id)


@router.patch("/{plant_id}", response_model=PlantOut)
def update_plant(
    plant_id: int,
    payload: PlantUpdate,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    result = svc.update_plant(db, garden_id, plant_id, payload)
    db.commit()
    return result


@router.delete("/{plant_id}", response_model=OkOut)
def delete_plant(
    plant_id: int,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    result = svc.delete_plant(db, garden_id, plant_id)
    db.commit()
    return result


@router.post("/{plant_id}/pool-status", response_model=PlantOut)
def set_pool_status(
    plant_id: int,
    payload: PoolStatusRequest,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    result = svc.set_pool_status(db, garden_id, plant_id, payload.status)
    db.commit()
    return result


@router.post("/{plant_id}/mark-planted", response_model=PlantOut)
def mark_planted(
    plant_id: int,
    payload: MarkPlantedRequest,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    result = svc.mark_planted(db, garden_id, plant_id, payload)
    db.commit()
    return result


@router.post("/{plant_id}/attach-to-area", response_model=AttachOut)
def attach_to_area(
    plant_id: int,
    payload: AttachRequest,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    result = svc.attach_to_area(db, garden_id, plant_id, payload)
    db.commit()
    return result


@router.post("/{plant_id}/detach-from-area", response_model=DetachOut)
def detach_from_area(
    plant_id: int,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    result = svc.detach_from_area(db, garden_id, plant_id)
    db.commit()
    return result


@router.post("/{plant_id}/move", response_model=MoveOut)
def move_plant(
    plant_id: int,
    payload: MoveRequest,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    result = svc.move_plant(db, garden_id, plant_id, payload)
    db.commit()
    return result