"""Handlers for account catalog."""

from typing import List, Optional

from flask.typing import ResponseReturnValue
from flask_pydantic import validate
from pydantic import Field, model_validator

from collaborator.api import app
from collaborator.constants.api import DEFAULT_PAGINATION_LIMIT
from collaborator.logic import product
from collaborator.schemas import BaseSchema, CommaSeparatedList
from collaborator.utils import handlers as utils


class GetProductsQuery(BaseSchema):
    """Query parameters for GET /products."""

    vendor_id: Optional[int] = None
    collaborator_id: Optional[int] = None
    limit: Optional[int] = DEFAULT_PAGINATION_LIMIT
    offset: Optional[int] = 0
    min_tracks_with_splits: Optional[int] = None
    max_tracks_with_splits: Optional[int] = None
    min_tracks_without_splits: Optional[int] = None
    max_tracks_without_splits: Optional[int] = None
    term: Optional[str] = None
    label_participant_uuids: Optional[CommaSeparatedList[str]] = None
    subaccount_id: Optional[int] = None
    deleted: Optional[bool] = None
    sort_key: Optional[str] = None
    sort_direction: Optional[str] = None

    @model_validator(mode="after")
    def _require_vendor_xor_collaborator(self):
        """Require exactly one of vendor_id or collaborator_id."""
        if bool(self.vendor_id) == bool(self.collaborator_id):
            raise ValueError("Exactly one of vendor_id or collaborator_id is required")
        return self


@app.route("/products", methods=["GET"])
@validate()
@utils.fetch_authorized_resources
def get_products(
    authorized_resources, user, query: GetProductsQuery
) -> ResponseReturnValue:
    """Get products for vendor."""
    result = product.get_products(
        authorized_resources=authorized_resources,
        vendor_id=query.vendor_id,
        collaborator_id=query.collaborator_id,
        limit=query.limit,
        offset=query.offset,
        min_tracks_with_splits=query.min_tracks_with_splits,
        max_tracks_with_splits=query.max_tracks_with_splits,
        min_tracks_without_splits=query.min_tracks_without_splits,
        max_tracks_without_splits=query.max_tracks_without_splits,
        term=query.term,
        label_participant_uuids=query.label_participant_uuids,
        subaccount_id=query.subaccount_id,
        deleted=query.deleted,
        sort_key=query.sort_key,
        sort_direction=query.sort_direction,
    )

    return result.message


class ProductCountsDataloaderBody(BaseSchema):
    """Request body for POST /products/counts-dataloader."""

    product_ids: List[int] = Field(min_length=1)


@app.route("/products/counts-dataloader", methods=["POST"])
@validate()
@utils.fetch_authorized_resources
def product_counts_dataloader(
    authorized_resources, user, body: ProductCountsDataloaderBody
) -> ResponseReturnValue:
    """Get counts for products by ID."""
    return product.get_counts_for_products(authorized_resources, body.product_ids)