# app/api/v1/vendor/inventory.py
"""
Vendor inventory management endpoints.

Vendor Context: Uses token_vendor_id from JWT token (authenticated vendor API pattern).
The get_current_vendor_api dependency guarantees token_vendor_id is present.
"""
import logging

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

from app.api.deps import get_current_vendor_api
from app.core.database import get_db
from app.services.inventory_service import inventory_service
from models.database.user import User
from models.schema.inventory import (
    InventoryAdjust,
    InventoryCreate,
    InventoryListResponse,
    InventoryMessageResponse,
    InventoryReserve,
    InventoryResponse,
    InventoryUpdate,
    ProductInventorySummary,
)

router = APIRouter()
logger = logging.getLogger(__name__)


@router.post("/inventory/set", response_model=InventoryResponse)
def set_inventory(
    inventory: InventoryCreate,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """Set exact inventory quantity (replaces existing)."""
    result = inventory_service.set_inventory(db, current_user.token_vendor_id, inventory)
    db.commit()
    return result


@router.post("/inventory/adjust", response_model=InventoryResponse)
def adjust_inventory(
    adjustment: InventoryAdjust,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """Adjust inventory (positive to add, negative to remove)."""
    result = inventory_service.adjust_inventory(db, current_user.token_vendor_id, adjustment)
    db.commit()
    return result


@router.post("/inventory/reserve", response_model=InventoryResponse)
def reserve_inventory(
    reservation: InventoryReserve,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """Reserve inventory for an order."""
    result = inventory_service.reserve_inventory(db, current_user.token_vendor_id, reservation)
    db.commit()
    return result


@router.post("/inventory/release", response_model=InventoryResponse)
def release_reservation(
    reservation: InventoryReserve,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """Release reserved inventory (cancel order)."""
    result = inventory_service.release_reservation(db, current_user.token_vendor_id, reservation)
    db.commit()
    return result


@router.post("/inventory/fulfill", response_model=InventoryResponse)
def fulfill_reservation(
    reservation: InventoryReserve,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """Fulfill reservation (complete order, remove from stock)."""
    result = inventory_service.fulfill_reservation(db, current_user.token_vendor_id, reservation)
    db.commit()
    return result


@router.get("/inventory/product/{product_id}", response_model=ProductInventorySummary)
def get_product_inventory(
    product_id: int,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """Get inventory summary for a product."""
    return inventory_service.get_product_inventory(db, current_user.token_vendor_id, product_id)


@router.get("/inventory", response_model=InventoryListResponse)
def get_vendor_inventory(
    skip: int = Query(0, ge=0),
    limit: int = Query(100, ge=1, le=1000),
    location: str | None = Query(None),
    low_stock: int | None = Query(None, ge=0),
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """Get all inventory for vendor."""
    inventories = inventory_service.get_vendor_inventory(
        db, current_user.token_vendor_id, skip, limit, location, low_stock
    )

    # Get total count
    total = len(inventories)  # You might want a separate count query for large datasets

    return InventoryListResponse(
        inventories=inventories, total=total, skip=skip, limit=limit
    )


@router.put("/inventory/{inventory_id}", response_model=InventoryResponse)
def update_inventory(
    inventory_id: int,
    inventory_update: InventoryUpdate,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """Update inventory entry."""
    result = inventory_service.update_inventory(
        db, current_user.token_vendor_id, inventory_id, inventory_update
    )
    db.commit()
    return result


@router.delete("/inventory/{inventory_id}", response_model=InventoryMessageResponse)
def delete_inventory(
    inventory_id: int,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """Delete inventory entry."""
    inventory_service.delete_inventory(db, current_user.token_vendor_id, inventory_id)
    db.commit()
    return InventoryMessageResponse(message="Inventory deleted successfully")
