"""
Pagination DTOs

Data transfer objects for pagination handling.
"""

from dataclasses import dataclass, field
from typing import Generic, TypeVar, List, Optional, Any

from .base import BaseDTO

T = TypeVar("T")


@dataclass
class PaginationParamsDTO(BaseDTO):
    """Pagination request parameters."""

    page: int = 1
    page_size: int = 20
    sort_by: Optional[str] = None
    sort_order: str = "asc"  # "asc" or "desc"
    search: Optional[str] = None
    filters: dict[str, Any] = field(default_factory=dict)

    def __post_init__(self):
        # Ensure valid values
        if self.page < 1:
            self.page = 1
        if self.page_size < 1:
            self.page_size = 20
        if self.page_size > 100:
            self.page_size = 100
        if self.sort_order not in ("asc", "desc"):
            self.sort_order = "asc"

    @property
    def offset(self) -> int:
        """Calculate offset for database queries."""
        return (self.page - 1) * self.page_size


@dataclass
class PaginatedResponseDTO(BaseDTO, Generic[T]):
    """Paginated response structure."""

    items: List[T] = field(default_factory=list)
    total: int = 0
    page: int = 1
    page_size: int = 20
    total_pages: int = 0
    has_next: bool = False
    has_previous: bool = False

    def __post_init__(self):
        if self.total > 0 and self.page_size > 0:
            self.total_pages = (self.total + self.page_size - 1) // self.page_size
            self.has_next = self.page < self.total_pages
            self.has_previous = self.page > 1

    @classmethod
    def create(
        cls,
        items: List[T],
        total: int,
        page: int,
        page_size: int,
    ) -> "PaginatedResponseDTO[T]":
        """Factory method to create paginated response."""
        return cls(
            items=items,
            total=total,
            page=page,
            page_size=page_size,
        )