"""Get post use case.

This module implements the use case for retrieving blog posts.
Supports lookup by both ID and slug.
"""

from uuid import UUID

from app.application.dtos.post import PostResponseDTO
from app.application.interfaces import TransactionManager
from app.domain.entities import Post
from app.domain.exceptions import NotFoundException
from app.domain.repositories import PostRepository


class GetPostUseCase:
    """Use case for retrieving a post by ID or slug.

    Provides methods to fetch posts using different identifiers.
    Handles not-found scenarios with appropriate exceptions.

    Attributes:
        _post_repo: Repository for post data access.
        _tx_manager: Transaction manager for transaction control.

    Example:
        >>> use_case = GetPostUseCase(post_repo, tx_manager)
        >>> post = await use_case.by_id(post_id)
        >>> post = await use_case.by_slug("my-post")
    """

    def __init__(
        self,
        post_repo: PostRepository,
        tx_manager: TransactionManager,
    ) -> None:
        """Initialize use case with dependencies.

        Args:
            post_repo: Repository for post operations.
            tx_manager: Transaction manager instance.
        """
        self._post_repo = post_repo
        self._tx_manager = tx_manager

    async def by_id(self, post_id: UUID) -> PostResponseDTO:
        """Get post by ID.

        Args:
            post_id: Unique identifier of the post.

        Returns:
            PostResponseDTO with complete post data.

        Raises:
            NotFoundException: If post with given ID does not exist.
        """
        post = await self._post_repo.get_by_id(post_id)
        if not post:
            raise NotFoundException(f"Post with id '{post_id}' not found")
        return self._map_to_dto(post)

    async def by_slug(self, slug: str) -> PostResponseDTO:
        """Get post by slug.

        Args:
            slug: URL-friendly slug identifier.

        Returns:
            PostResponseDTO with complete post data.

        Raises:
            NotFoundException: If post with given slug does not exist.
        """
        post = await self._post_repo.get_by_slug(slug)
        if not post:
            raise NotFoundException(f"Post with slug '{slug}' not found")
        return self._map_to_dto(post)

    def _map_to_dto(self, post: Post) -> PostResponseDTO:
        """Map domain entity to response DTO.

        Args:
            post: Domain post entity.

        Returns:
            PostResponseDTO with all post attributes.
        """
        return PostResponseDTO(
            id=post.id,
            title=post.title.value,
            content=post.content.value,
            slug=post.slug.value,
            author_id=post.author_id,
            published=post.published,
            like_count=post.like_count,
            tags=post.tags.copy(),
            created_at=post.created_at,
            updated_at=post.updated_at,
        )