class FeedService(BaseService):
    """
    Service for interacting with the feed endpoints of the Lobstr API.

    Methods:
        `hot(page: int = 1) -> Feed`: Retrieve the hottest posts from the feed.
        `new(page: int = 1) -> Feed`: Retrieve the newest posts from the feed.
        `tag(tag: str, page: int = 1) -> Feed`: Retrieve posts associated with a specific tag.
        `filter(*tag: str, page: int = 1) -> Feed`: Retrieve posts associated with multiple tags.
    """

    async def _feed(self, endpoint: str, page: int = 1) -> Feed:
        """
        Internal method to retrieve feed data from a specific endpoint and page.
        """
        resp = await self._client.get(f"{endpoint}/page/{page}.json")
        if resp.status_code == 404:
            raise FeedPageNotFound(
                page=page,
                endpoint=resp.url,
            )
        resp.raise_for_status()

        return Feed.model_validate(
            {
                "page": page,
                "posts": resp.json(),
            }
        )

    async def hot(self, page: int = 1) -> Feed:
        """
        Retrieve the hottest posts from the feed.

        Args:
            page (int): The page number to retrieve. Defaults to 1.

        Returns:
            Feed: The feed object containing the hottest posts for the specified page.

        Raises:
            FeedPageNotFound: If the specified page does not exist in the feed.
            HTTPError: If the request to the API fails for any other reason.
        """
        resp = await self._feed("/hottest", page)
        return resp

    async def new(self, page: int = 1) -> Feed:
        """
        Retrieve the newest posts from the feed.

        Args:
            page (int): The page number to retrieve. Defaults to 1.


        Returns:
            Feed: The feed object containing the newest posts for the specified page.

        Raises:
            FeedPageNotFound: If the specified page does not exist in the feed.
            HTTPError: If the request to the API fails for any other reason.
        """
        resp = await self._feed("/newest", page)
        return resp

    async def tag(self, tag: str, page: int = 1) -> Feed:
        """
        Retrieve posts associated with a specific tag.

        Args:
            tag (str): The tag to filter posts by.
            page (int): The page number to retrieve. Defaults to 1.

        Returns:
            Feed: The feed object containing posts associated with the specified tag for the specified page.

        Raises:
            FeedPageNotFound: If the specified page does not exist for the given tag in the feed.
            HTTPError: If the request to the API fails for any other reason.
        """
        resp = await self._feed(f"/t/{tag}", page)
        return resp

    async def filter(self, *tag: str, page: int = 1) -> Feed:
        """
        Retrieve posts associated with multiple tags.

        Args:
            *tag (str): The tags to filter posts by.
            page (int): The page number to retrieve. Defaults to 1.

        Returns:
            Feed: The feed object containing posts associated with the specified tags for the specified page.

        Raises:
            FeedPageNotFound: If the specified page does not exist for the given tags in the feed.
            HTTPError: If the request to the API fails for any other reason.
        """
        resp = await self._feed(f"/t/{','.join(tag)}", page)
        return resp

class StoryService(BaseService):
    """
    Service for interacting with the story endpoints of the Lobstr API.

    Methods:
        `get(short_id: str) -> Story`: Retrieve a story by its short ID.
    """

    async def get(self, short_id: str) -> Story:
        """
        Retrieve a story by its short ID.

        Args:
            short_id (str): The short ID of the story to retrieve.

        Returns:
            Story: An instance of the Story model representing the retrieved story.

        Raises:
            StoryNotFound: If the story with the given short ID does not exist.
            HTTPError: If the request to the API fails for any other reason.
        """
        resp = await self._client.get(f"/s/{short_id}.json")
        if resp.status_code == 404:
            raise StoryNotFound(
                story_id=short_id,
                endpoint=resp.url,
            )
        resp.raise_for_status()
        return Story.model_validate(resp.json())

class CommentService(BaseService):
    """
    Service for interacting with the comments API.

    Methods:
        `get(short_id: str) -> Comment`: Retrieve a comment by its short ID.
    """

    async def get(self, short_id: str) -> Comment:
        """
        Retrieve a comment by its short ID.

        Args:
            short_id (str): The short ID of the comment to retrieve.

        Returns:
            Comment: The retrieved comment.

        Raises:
            CommentNotFound: If the comment with the given short ID does not exist.
            HTTPError: If the request to the API fails for any other reason.
        """
        resp = await self._client.get(f"/c/{short_id}.json")
        if resp.status_code == 400 and resp.text == "can't find comment":
            raise CommentNotFound(
                comment_id=short_id,
                endpoint=resp.url,
            )
        resp.raise_for_status()
        return Comment.model_validate(resp.json())

class UserService(BaseService):
    """
    Service for interacting with the Lobstr API's user endpoints.

    Methods:
        `get(username: str) -> User`: Fetches user information by username.
    """

    async def get(self, username: str) -> User:
        """
        Fetches user information by username.

        Args:
            username (str): The username of the user to fetch.

        Returns:
            User: An instance of the User model containing user information.

        Raises:
            UserNotFound: If the user with the specified username does not exist.
            HTTPError: If the request to the API fails for any other reason.
        """
        resp = await self._client.get(f"/~{username}.json")
        if resp.status_code == 404:
            raise UserNotFound(username, endpoint=self._client.base_url)
        resp.raise_for_status()
        return User.model_validate(resp.json())

class TagService(BaseService):
    """
    Service for interacting with the tag endpoints of the Lobstr API.

    Methods:
        `get(name: str) -> Tag`: Retrieve a tag by its name.
        `list() -> List[Tag]`: Retrieve a list of all available tags.
    """

    async def get(self, name: str) -> Tag:
        """
        Retrieve a tag by its name.

        Args:
            name (str): The name of the tag to retrieve.

        Returns:
            Tag: The tag object corresponding to the provided name.

        Raises:
            TagNotFound: If the tag with the specified name does not exist.
        """
        tags = await self.list()
        for tag in tags:
            if tag.name == name:
                return tag
        raise TagNotFound(name, endpoint=self._client.base_url)

    async def list(self) -> List[Tag]:
        """
        Retrieve a list of all available tags.

        Returns:
            List[Tag]: A list of tag objects.
        """
        resp = await self._client.get("/tags.json")
        resp.raise_for_status()
        return Tags.validate_python(resp.json())