kemoverse/bot/response.py

from datetime import datetime, timedelta, timezone
from typing import TypedDict, Any, List, Dict
from db_utils import get_or_create_user, insert_pull, get_last_rolled_at, \
        get_random_character
from add_character import add_character
from config import GACHA_ROLL_INTERVAL
from custom_types import BotResponse, ParsedNotification


def do_roll(full_user: str) -> BotResponse:
    '''Determines whether the user can roll, then pulls a random character'''
    user_id = get_or_create_user(full_user)

    # Get date of user's last roll
    date = get_last_rolled_at(user_id)

    # No date means it's users first roll
    if date:
        # SQLite timestamps returned by the DB are always in UTC
        # Below timestamps are to be converted to UTC
        prev = datetime.strptime(str(date) + '+0000', '%Y-%m-%d %H:%M:%S%z')
        now = datetime.now(timezone.utc)

        time_since_last_roll = now - prev
        roll_interval = timedelta(seconds=GACHA_ROLL_INTERVAL)
        duration = roll_interval - time_since_last_roll

        # User needs to wait before they can roll again
        if time_since_last_roll < roll_interval:
            remaining_duration = None
            if duration.seconds > 3600:
                remaining_duration = f'{-(duration.seconds // -3600)} hours'
            elif duration.seconds > 60:
                remaining_duration = f'{-(duration.seconds // -60)} minutes'
            else:
                remaining_duration = f'{duration.seconds} seconds'

            return {
                'message': f'{full_user} ⏱️ Please wait another \
{remaining_duration} before rolling again.',
                'attachment_urls': None
            }

    character = get_random_character()

    if not character:
        return {
            'message': f'{full_user} Uwaaa... something went wrong! No \
characters found. 😿',
            'attachment_urls': None
        }

    insert_pull(user_id, character['id'])
    stars = '⭐️' * character['rarity']
    return {
        'message': f'@{full_user} 🎲 Congrats! You rolled {stars} \
**{character['name']}**\nShe\'s all yours now~ 💖✨',
        'attachment_urls': [character['image_url']]
    }


def is_float(val: Any) -> bool:
    '''Returns true if `val` can be converted to a float'''
    try:
        float(val)
        return True
    except ValueError:
        return False


def do_create(
        full_user: str,
        arguments: List[str],
        note_obj: Dict[str, Any]) -> BotResponse:
    '''Creates a character'''
    # Example call from bot logic
    image_url = note_obj.get('files', [{}])[0].get('url') \
        if note_obj.get('files') else None

    if not image_url:
        return {
            'message': f'{full_user} You need an image to create a character, \
dumbass.',
            'attachment_urls': None
        }

    if len(arguments) != 3:
        return {
            'message': f'{full_user} Please specify the following attributes \
in order: name, rarity, drop weighting',
            'attachment_urls': None
        }

    if not (arguments[1].isnumeric() and 1 <= int(arguments[1]) <= 5):
        return {
            'message': f'{full_user} Invalid rarity: \'{arguments[1]}\' must \
be a number between 1 and 5',
            'attachment_urls': None
        }
    if not (is_float(arguments[2]) and 0.0 < float(arguments[2]) <= 1.0):
        return {
            'message': f'{full_user} Invalid drop weight: \'{arguments[2]}\' \
must be a decimal value between 0.0 and 1.0',
            'attachment_urls': None
        }

    character_id, file_id = add_character(
        name=arguments[0],
        rarity=int(arguments[1]),
        weight=float(arguments[2]),
        image_url=image_url
    )
    return {
        'message': f'{full_user} Added {arguments[0]}, ID {character_id}.',
        'attachment_urls': [file_id]
    }


def do_help(author: str) -> BotResponse:
    '''Provides a list of commands that the bot can do.'''
    return {
        'message': f'{author} Here\'s what I can do:\n\
- `roll` Pulls a random character.\n\
- `create <name> <rarity> <weight>` Creates a character using a given image.\n\
- `help` Shows this message.',
        'attachment_urls': None
    }


def do_signup() -> BotResponse:
    return {
        'message': '',
        'attachment_urls': None
    }


def generate_response(notification: ParsedNotification) -> BotResponse | None:
    '''Given a command with arguments, processes the game state and
    returns a response'''

    # Temporary response variable
    res: BotResponse | None = None
    # TODO: Check if the user has an account
    author = notification['author']
    user_id = get_or_create_user(author)
    command = notification['command']
    # Check if the user is an administrator
    # user_is_administrator = user_is_administrator()

    # Unrestricted commands
    match command:
        case 'signup':
            res = do_signup()
        case 'help':
            res = do_help(author)
        case _:
            pass

    if not user_id:
        return res

    # User commands
    match command:
        case 'delete_account':
            pass
        case 'roll':
            res = do_roll(author)
        case 'create':
            res = do_create(
                author,
                notification['arguments'],
                notification['note_obj']
            )
        case _:
            pass
    # if not user_is_administrator:
    return res

    # Administrator commands go here