# app/api/v1/vendor/products.py
"""
Vendor product catalog 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.product_service import product_service
from models.database.user import User
from models.schema.product import (
    ProductCreate,
    ProductDeleteResponse,
    ProductDetailResponse,
    ProductListResponse,
    ProductResponse,
    ProductToggleResponse,
    ProductUpdate,
)

router = APIRouter(prefix="/products")
logger = logging.getLogger(__name__)


@router.get("", response_model=ProductListResponse)
def get_vendor_products(
    skip: int = Query(0, ge=0),
    limit: int = Query(100, ge=1, le=1000),
    is_active: bool | None = Query(None),
    is_featured: bool | None = Query(None),
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """
    Get all products in vendor catalog.

    Supports filtering by:
    - is_active: Filter active/inactive products
    - is_featured: Filter featured products

    Vendor is determined from JWT token (vendor_id claim).
    """
    products, total = product_service.get_vendor_products(
        db=db,
        vendor_id=current_user.token_vendor_id,
        skip=skip,
        limit=limit,
        is_active=is_active,
        is_featured=is_featured,
    )

    return ProductListResponse(
        products=[ProductResponse.model_validate(p) for p in products],
        total=total,
        skip=skip,
        limit=limit,
    )


@router.get("/{product_id}", response_model=ProductDetailResponse)
def get_product_details(
    product_id: int,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """Get detailed product information including inventory."""
    product = product_service.get_product(
        db=db, vendor_id=current_user.token_vendor_id, product_id=product_id
    )

    return ProductDetailResponse.model_validate(product)


@router.post("", response_model=ProductResponse)
def add_product_to_catalog(
    product_data: ProductCreate,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """
    Add a product from marketplace to vendor catalog.

    This publishes a MarketplaceProduct to the vendor's public catalog.
    """
    product = product_service.create_product(
        db=db, vendor_id=current_user.token_vendor_id, product_data=product_data
    )
    db.commit()

    logger.info(
        f"Product {product.id} added to catalog by user {current_user.username} "
        f"for vendor {current_user.token_vendor_code}"
    )

    return ProductResponse.model_validate(product)


@router.put("/{product_id}", response_model=ProductResponse)
def update_product(
    product_id: int,
    product_data: ProductUpdate,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """Update product in vendor catalog."""
    product = product_service.update_product(
        db=db,
        vendor_id=current_user.token_vendor_id,
        product_id=product_id,
        product_update=product_data,
    )
    db.commit()

    logger.info(
        f"Product {product_id} updated by user {current_user.username} "
        f"for vendor {current_user.token_vendor_code}"
    )

    return ProductResponse.model_validate(product)


@router.delete("/{product_id}", response_model=ProductDeleteResponse)
def remove_product_from_catalog(
    product_id: int,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """Remove product from vendor catalog."""
    product_service.delete_product(
        db=db, vendor_id=current_user.token_vendor_id, product_id=product_id
    )
    db.commit()

    logger.info(
        f"Product {product_id} removed from catalog by user {current_user.username} "
        f"for vendor {current_user.token_vendor_code}"
    )

    return ProductDeleteResponse(message=f"Product {product_id} removed from catalog")


@router.post("/from-import/{marketplace_product_id}", response_model=ProductResponse)
def publish_from_marketplace(
    marketplace_product_id: int,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """
    Publish a marketplace product to vendor catalog.

    Shortcut endpoint for publishing directly from marketplace import.
    """
    product_data = ProductCreate(
        marketplace_product_id=marketplace_product_id, is_active=True
    )

    product = product_service.create_product(
        db=db, vendor_id=current_user.token_vendor_id, product_data=product_data
    )
    db.commit()

    logger.info(
        f"Marketplace product {marketplace_product_id} published to catalog "
        f"by user {current_user.username} for vendor {current_user.token_vendor_code}"
    )

    return ProductResponse.model_validate(product)


@router.put("/{product_id}/toggle-active", response_model=ProductToggleResponse)
def toggle_product_active(
    product_id: int,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """Toggle product active status."""
    product = product_service.get_product(
        db, current_user.token_vendor_id, product_id
    )

    product.is_active = not product.is_active
    db.commit()
    db.refresh(product)

    status = "activated" if product.is_active else "deactivated"
    logger.info(f"Product {product_id} {status} for vendor {current_user.token_vendor_code}")

    return ProductToggleResponse(message=f"Product {status}", is_active=product.is_active)


@router.put("/{product_id}/toggle-featured", response_model=ProductToggleResponse)
def toggle_product_featured(
    product_id: int,
    current_user: User = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """Toggle product featured status."""
    product = product_service.get_product(
        db, current_user.token_vendor_id, product_id
    )

    product.is_featured = not product.is_featured
    db.commit()
    db.refresh(product)

    status = "featured" if product.is_featured else "unfeatured"
    logger.info(f"Product {product_id} {status} for vendor {current_user.token_vendor_code}")

    return ProductToggleResponse(message=f"Product {status}", is_featured=product.is_featured)
