"""Search torrents use case."""

import logging

from infrastructure.api.knaben import KnabenAPIError, KnabenClient, KnabenNotFoundError

from .dto import SearchTorrentsResponse

logger = logging.getLogger(__name__)


class SearchTorrentsUseCase:
    """
    Use case for searching torrents.

    This orchestrates the Knaben API client to find torrents.
    """

    def __init__(self, knaben_client: KnabenClient):
        """
        Initialize use case.

        Args:
            knaben_client: Knaben API client
        """
        self.knaben_client = knaben_client

    def execute(self, media_title: str, limit: int = 10) -> SearchTorrentsResponse:
        """
        Search for torrents by media title.

        Args:
            media_title: Title of the media to search for
            limit: Maximum number of results

        Returns:
            SearchTorrentsResponse with torrent information or error
        """
        try:
            # Search for torrents
            results = self.knaben_client.search(media_title, limit=limit)

            if not results:
                logger.info(f"No torrents found for '{media_title}'")
                return SearchTorrentsResponse(
                    status="error",
                    error="not_found",
                    message=f"No torrents found for '{media_title}'",
                )

            # Convert to dict format
            torrents = []
            for torrent in results:
                torrents.append(
                    {
                        "name": torrent.title,
                        "size": torrent.size,
                        "seeders": torrent.seeders,
                        "leechers": torrent.leechers,
                        "magnet": torrent.magnet,
                        "info_hash": torrent.info_hash,
                        "tracker": torrent.tracker,
                        "upload_date": torrent.upload_date,
                        "category": torrent.category,
                    }
                )

            logger.info(f"Found {len(torrents)} torrents for '{media_title}'")

            return SearchTorrentsResponse(
                status="ok", torrents=torrents, count=len(torrents)
            )

        except KnabenNotFoundError as e:
            logger.info(f"Torrents not found: {e}")
            return SearchTorrentsResponse(
                status="error", error="not_found", message=str(e)
            )

        except KnabenAPIError as e:
            logger.error(f"Knaben API error: {e}")
            return SearchTorrentsResponse(
                status="error", error="api_error", message=str(e)
            )

        except ValueError as e:
            logger.error(f"Validation error: {e}")
            return SearchTorrentsResponse(
                status="error", error="validation_failed", message=str(e)
            )