"""Inventory routes: /api/supplies + /api/stations (+ areas-served set).

Thin + sync per standards. PUT /api/stations/{id}/areas is the v2 form of
v1's POST /api/station/{id}/areas one-shot M2M replace.
"""
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.inventory import (
    OkResult,
    StationAreasResult,
    StationAreasSet,
    StationCreate,
    StationDetail,
    StationOut,
    StationPatch,
    SupplyCreate,
    SupplyOut,
    SupplyPatch,
)
from ..services import inventory

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


# --- supplies -----------------------------------------------------------------

@router.get("/supplies", response_model=list[SupplyOut])
def supply_list(
    archived: int = Query(0),
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    return inventory.list_supplies(db, garden_id, include_archived=bool(archived))


@router.post("/supplies", response_model=SupplyOut, status_code=201)
def supply_create(
    body: SupplyCreate,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    return inventory.create_supply(
        db,
        garden_id,
        name=body.name,
        category=body.category,
        quantity_on_hand=body.quantity_on_hand,
        quantity_needed=body.quantity_needed,
        needed=body.needed,
        notes=body.notes,
    )


@router.get("/supplies/{supply_id}", response_model=SupplyOut)
def supply_detail(
    supply_id: int,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    return inventory.get_supply(db, garden_id, supply_id)


@router.patch("/supplies/{supply_id}", response_model=SupplyOut)
def supply_update(
    supply_id: int,
    body: SupplyPatch,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    return inventory.update_supply(
        db, garden_id, supply_id, body.model_dump(exclude_unset=True)
    )


@router.delete("/supplies/{supply_id}", response_model=OkResult)
def supply_delete(
    supply_id: int,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    inventory.delete_supply(db, garden_id, supply_id)
    return OkResult()


# --- stations -----------------------------------------------------------------

@router.get("/stations", response_model=list[StationOut])
def station_list(
    archived: int = Query(0),
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    return inventory.list_stations(db, garden_id, include_archived=bool(archived))


@router.post("/stations", response_model=StationDetail, status_code=201)
def station_create(
    body: StationCreate,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    return inventory.create_station(
        db,
        garden_id,
        name=body.name,
        notes=body.notes,
        current_schedule=body.current_schedule,
        area_ids=body.area_ids,
    )


@router.get("/stations/{station_id}", response_model=StationDetail)
def station_detail(
    station_id: int,
    archived: int = Query(0),
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    return inventory.get_station(
        db, garden_id, station_id, include_archived=bool(archived)
    )


@router.patch("/stations/{station_id}", response_model=StationDetail)
def station_update(
    station_id: int,
    body: StationPatch,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    return inventory.update_station(
        db, garden_id, station_id, body.model_dump(exclude_unset=True)
    )


@router.put("/stations/{station_id}/areas", response_model=StationAreasResult)
def station_set_areas(
    station_id: int,
    body: StationAreasSet,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    stored = inventory.set_station_areas(db, garden_id, station_id, body.area_ids)
    return StationAreasResult(area_ids=stored)


@router.delete("/stations/{station_id}", response_model=OkResult)
def station_delete(
    station_id: int,
    db: Session = Depends(get_db),
    garden_id: int = Depends(current_garden_id),
):
    inventory.delete_station(db, garden_id, station_id)
    return OkResult()