meshcore-bot/modules/commands/dadjoke_command.py

#!/usr/bin/env python3
"""
Dad Joke Command for MeshCore Bot
Fetches dad jokes from icanhazdadjoke.com API
"""

import asyncio
import logging
from typing import Any, Optional

import aiohttp

from ..models import MeshMessage
from .base_command import BaseCommand

logger = logging.getLogger("MeshCoreBot")

class DadJokeCommand(BaseCommand):
    """Handles dad joke commands using icanhazdadjoke.com API"""

    # Plugin metadata
    # Read-only informational output; safe for scheduled {cmd:...} rendering.
    render_safe = True
    name = "dadjoke"
    keywords = ['dadjoke', 'dad joke', 'dadjokes', 'dad jokes']
    description = "Get a random dad joke from icanhazdadjoke.com"
    category = "fun"
    cooldown_seconds = 3
    requires_internet = True  # Requires internet access for API calls

    # Documentation
    short_description = "Get a random dad joke"
    usage = "dadjoke"
    examples = ["dadjoke"]

    # Web-viewer settings schema (see modules/settings_schema.py)
    settings_schema = [
        {
            "key": "long_jokes",
            "label": "Allow long jokes",
            "type": "bool",
            "default": False,
            "help": "Permit multi-message long-form jokes instead of short one-liners.",
        },
    ]

    # API configuration
    DAD_JOKE_API_URL = "https://icanhazdadjoke.com/"
    TIMEOUT = 10  # seconds

    def __init__(self, bot):
        """Initialize the dadjoke command.

        Args:
            bot: The bot instance.
        """
        super().__init__(bot)

        # Load configuration (enabled standard; dadjoke_enabled legacy from [DadJoke_Command] or [Jokes])
        self.dadjoke_enabled = self.get_config_value('DadJoke_Command', 'enabled', fallback=None, value_type='bool')
        if self.dadjoke_enabled is None:
            self.dadjoke_enabled = self.get_config_value('DadJoke_Command', 'dadjoke_enabled', fallback=True, value_type='bool')
        self.long_jokes = self.get_config_value('DadJoke_Command', 'long_jokes', fallback=False, value_type='bool')

    def get_help_text(self) -> str:
        """Get help text for the dadjoke command.

        Returns:
            str: The help text for this command.
        """
        return "Usage: dadjoke - Get a random dad joke"

    def matches_keyword(self, message: MeshMessage) -> bool:
        """Check if message starts with a dad joke keyword.

        Args:
            message: The received message.

        Returns:
            bool: True if message matches a keyword, False otherwise.
        """
        content_lower = self.cleanup_message_for_matching(message)
        return any(content_lower == keyword or content_lower.startswith(keyword + ' ') for keyword in self.keywords)

    def can_execute(self, message: MeshMessage, skip_channel_check: bool = False) -> bool:
        """Override to add custom check (dadjoke_enabled) while using base class cooldown.

        Args:
            message: The message triggering the command.

        Returns:
            bool: True if the command can be executed, False otherwise.
        """
        # Use base class for channel access, DM requirements, and cooldown
        if not super().can_execute(message):
            return False

        # Check if dadjoke command is enabled
        return self.dadjoke_enabled

    async def execute(self, message: MeshMessage) -> bool:
        """Execute the dad joke command.

        Args:
            message: The message triggering the command.

        Returns:
            bool: True if executed successfully, False otherwise.
        """
        try:
            # Record execution for this user
            self.record_execution(message.sender_id)

            # Get dad joke from API with length handling
            joke_data = await self.get_dad_joke_with_length_handling()

            if joke_data is None:
                await self.send_response(message, "Sorry, couldn't fetch a dad joke right now. Try again later!")
                return True

            # Format and send the joke(s)
            await self.send_dad_joke_with_length_handling(message, joke_data)

            return True

        except Exception as e:
            self.logger.error(f"Error in dad joke command: {e}")
            await self.send_response(message, "Sorry, something went wrong getting a dad joke!")
            return True

    async def get_dad_joke_from_api(self) -> Optional[dict[str, Any]]:
        """Get a dad joke from icanhazdadjoke.com API.

        Returns:
            Optional[Dict[str, Any]]: The JSON response from the API, or None if failed.
        """
        try:
            headers = {
                'Accept': 'application/json',
                'User-Agent': 'MeshCoreBot (https://github.com/agessaman/meshcore-bot)'
            }

            self.logger.debug(f"Fetching dad joke from: {self.DAD_JOKE_API_URL}")

            # Make the API request
            async with aiohttp.ClientSession() as session, session.get(
                self.DAD_JOKE_API_URL,
                headers=headers,
                timeout=aiohttp.ClientTimeout(total=self.TIMEOUT)
            ) as response:
                if response.status == 200:
                    data = await response.json()

                    # Check if the API returned an error
                    if data.get('status') != 200:
                        self.logger.warning(f"Dad joke API returned error status: {data.get('status')}")
                        return None

                    # Validate required fields
                    if not data.get('joke'):
                        self.logger.warning("Dad joke API returned joke without content")
                        return None

                    return data
                else:
                    self.logger.error(f"Dad joke API returned status {response.status}")
                    return None

        except asyncio.TimeoutError:
            self.logger.error("Timeout fetching dad joke from API")
            return None
        except Exception as e:
            self.logger.error(f"Error fetching dad joke from API: {e}")
            return None

    async def get_dad_joke_with_length_handling(self) -> Optional[dict[str, Any]]:
        """Get a dad joke from API with length handling based on configuration.

        Returns:
            Optional[Dict[str, Any]]: The JSON response from the API, or None if failed.
        """
        max_attempts = 5  # Prevent infinite loops

        for _attempt in range(max_attempts):
            joke_data = await self.get_dad_joke_from_api()

            if joke_data is None:
                return None

            # Check joke length
            joke_text = self.format_dad_joke(joke_data)

            if len(joke_text) <= 130:
                # Joke is short enough, return it
                return joke_data
            elif self.long_jokes:
                # Long jokes are enabled, return it for splitting
                return joke_data
            else:
                # Long jokes are disabled, try again
                self.logger.debug(f"Dad joke too long ({len(joke_text)} chars), fetching another...")
                continue

        # If we've tried max_attempts times and still getting long jokes, return the last one
        self.logger.warning(f"Could not get short dad joke after {max_attempts} attempts")
        return joke_data

    async def send_dad_joke_with_length_handling(self, message: MeshMessage, joke_data: dict[str, Any]) -> None:
        """Send dad joke with length handling - split if necessary.

        Args:
            message: The message to reply to.
            joke_data: The joke data from the API.
        """
        joke_text = self.format_dad_joke(joke_data)

        if len(joke_text) <= 130:
            # Joke is short enough, send as single message
            await self.send_response(message, joke_text)
        else:
            # Joke is too long, split it
            parts = self.split_dad_joke(joke_text)

            if len(parts) == 2 and len(parts[0]) <= 130 and len(parts[1]) <= 130:
                # Can be split into two messages (per-user rate limit applies only to first)
                await self.send_response(message, parts[0])
                # Use conservative delay to avoid rate limiting (same as weather command)
                await self.send_response(message, parts[1], skip_user_rate_limit=True)
            else:
                # Cannot be split properly, send as single message (user will see truncation)
                await self.send_response(message, joke_text)

    def split_dad_joke(self, joke_text: str) -> list:
        """Split a long dad joke at a logical point.

        Args:
            joke_text: The long joke text to split.

        Returns:
            list: A list of two strings (the split parts).
        """
        # Remove emoji for splitting
        clean_joke = joke_text[2:] if joke_text.startswith('🥸 ') else joke_text

        # Try to split at common logical points
        split_points = [
            '. ',     # Period followed by space
            '? ',     # Question mark followed by space
            '! ',     # Exclamation mark followed by space
            ', ',     # Comma followed by space
        ]

        for split_point in split_points:
            if split_point in clean_joke:
                parts = clean_joke.split(split_point, 1)
                if len(parts) == 2:
                    # Add emoji back to both parts
                    return [f"🥸 {parts[0]}{split_point}", f"🥸 {parts[1]}"]

        # If no good split point found, split at middle
        mid_point = len(clean_joke) // 2
        # Find nearest space to avoid splitting words
        for i in range(mid_point, len(clean_joke)):
            if clean_joke[i] == ' ':
                mid_point = i
                break

        part1 = clean_joke[:mid_point]
        part2 = clean_joke[mid_point + 1:]

        return [f"🥸 {part1}", f"🥸 {part2}"]

    def format_dad_joke(self, joke_data: dict[str, Any]) -> str:
        """Format the dad joke data into a readable string.

        Args:
            joke_data: The joke data from the API.

        Returns:
            str: The formatted joke string.
        """
        try:
            joke = joke_data.get('joke', '')

            if joke:
                return f"🥸 {joke}"
            else:
                return "🥸 No dad joke content available"

        except Exception as e:
            self.logger.error(f"Error formatting dad joke: {e}")
            return "🥸 Sorry, couldn't format the dad joke properly!"