# app/modules/customers/routes/api/store.py
"""
Store customer management endpoints.

Store Context: Uses token_store_id from JWT token (authenticated store API pattern).
The get_current_store_api dependency guarantees token_store_id is present.
"""

import logging

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

from app.api.deps import get_current_store_api, require_module_access
from app.core.database import get_db
from app.modules.customers.schemas import (
    CustomerDetailResponse,
    CustomerMessageResponse,
    CustomerResponse,
    CustomerUpdate,
    StoreCustomerListResponse,
)
from app.modules.customers.services import customer_service
from app.modules.enums import FrontendType
from app.modules.tenancy.schemas.auth import UserContext

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


@router.get("", response_model=StoreCustomerListResponse)
def get_store_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_store_api),
    db: Session = Depends(get_db),
):
    """
    Get all customers for this store.

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

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


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

    - Get customer by ID
    - Verify customer belongs to store

    Note: Order statistics are available via the orders module endpoint:
    GET /api/store/customers/{customer_id}/order-stats
    """
    # Service will raise CustomerNotFoundException if not found
    customer = customer_service.get_customer(
        db=db,
        store_id=current_user.token_store_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,
    )


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

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

    db.commit()

    return CustomerMessageResponse(message="Customer updated successfully")


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

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

    db.commit()

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