# app/modules/customers/routes/api/vendor.py
"""
Vendor customer 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, require_module_access
from app.core.database import get_db
from app.modules.customers.services import customer_service
from app.modules.enums import FrontendType
from models.schema.auth import UserContext
from app.modules.customers.schemas import (
    CustomerDetailResponse,
    CustomerMessageResponse,
    CustomerResponse,
    CustomerUpdate,
    VendorCustomerListResponse,
)

# Create module-aware router
vendor_router = APIRouter(
    prefix="/customers",
    dependencies=[Depends(require_module_access("customers", FrontendType.VENDOR))],
)
logger = logging.getLogger(__name__)


@vendor_router.get("", response_model=VendorCustomerListResponse)
def get_vendor_customers(
    skip: int = Query(0, ge=0),
    limit: int = Query(100, ge=1, le=1000),
    search: str | None = Query(None),
    is_active: bool | None = Query(None),
    current_user: UserContext = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """
    Get all customers for this vendor.

    - Query customers filtered by vendor_id
    - Support search by name/email
    - Support filtering by active status
    - Return paginated results
    """
    customers, total = customer_service.get_vendor_customers(
        db=db,
        vendor_id=current_user.token_vendor_id,
        skip=skip,
        limit=limit,
        search=search,
        is_active=is_active,
    )

    return VendorCustomerListResponse(
        customers=[CustomerResponse.model_validate(c) for c in customers],
        total=total,
        skip=skip,
        limit=limit,
    )


@vendor_router.get("/{customer_id}", response_model=CustomerDetailResponse)
def get_customer_details(
    customer_id: int,
    current_user: UserContext = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """
    Get detailed customer information.

    - Get customer by ID
    - Verify customer belongs to vendor

    Note: Order statistics are available via the orders module endpoint:
    GET /api/vendor/customers/{customer_id}/order-stats
    """
    # Service will raise CustomerNotFoundException if not found
    customer = customer_service.get_customer(
        db=db,
        vendor_id=current_user.token_vendor_id,
        customer_id=customer_id,
    )

    return CustomerDetailResponse(
        id=customer.id,
        email=customer.email,
        first_name=customer.first_name,
        last_name=customer.last_name,
        phone=customer.phone,
        customer_number=customer.customer_number,
        is_active=customer.is_active,
        marketing_consent=customer.marketing_consent,
        created_at=customer.created_at,
    )


@vendor_router.put("/{customer_id}", response_model=CustomerMessageResponse)
def update_customer(
    customer_id: int,
    customer_data: CustomerUpdate,
    current_user: UserContext = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """
    Update customer information.

    - Update customer details
    - Verify customer belongs to vendor
    """
    # Service will raise CustomerNotFoundException if not found
    customer_service.update_customer(
        db=db,
        vendor_id=current_user.token_vendor_id,
        customer_id=customer_id,
        customer_data=customer_data,
    )

    db.commit()

    return CustomerMessageResponse(message="Customer updated successfully")


@vendor_router.put("/{customer_id}/status", response_model=CustomerMessageResponse)
def toggle_customer_status(
    customer_id: int,
    current_user: UserContext = Depends(get_current_vendor_api),
    db: Session = Depends(get_db),
):
    """
    Activate/deactivate customer account.

    - Toggle customer is_active status
    - Verify customer belongs to vendor
    """
    # Service will raise CustomerNotFoundException if not found
    customer = customer_service.toggle_customer_status(
        db=db,
        vendor_id=current_user.token_vendor_id,
        customer_id=customer_id,
    )

    db.commit()

    status = "activated" if customer.is_active else "deactivated"
    return CustomerMessageResponse(message=f"Customer {status} successfully")