#Kemoverse - a gacha-style bot for the Fediverse.
#Copyright © 2025 Waifu, VD15 and contributors.
#
#This program is free software: you can redistribute it and/or modify
#it under the terms of the GNU Affero General Public License as
#published by the Free Software Foundation, either version 3 of the
#License, or (at your option) any later version.
#
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#GNU Affero General Public License for more details.
#
#You should have received a copy of the GNU Affero General Public License
#along with this program.  If not, see https://www.gnu.org/licenses/.

from datetime import datetime, timedelta, timezone
from typing import TypedDict, Any, List, Dict
import db_utils as db
from add_card import add_card
from config import GACHA_ROLL_INTERVAL
from custom_types import BotResponse, ParsedNotification


def do_roll(author: str) -> BotResponse:
    '''Determines whether the user can roll, then pulls a random card'''
    user_id = db.get_player(author)
    if not user_id:
        return {
            'message': f'{author} 🛑 You haven’t signed up yet! Use the \
`signup` command to start playing.',
            'attachment_urls': None
        }
    # Get date of user's last roll
    date = db.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'{author} ⏱️ Please wait another \
{remaining_duration} before rolling again.',
                'attachment_urls': None
            }

    card = db.get_random_card()

    if not card:
        return {
            'message': f'{author} Uwaaa... something went wrong! No \
cards found. 😿',
            'attachment_urls': None
        }

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


def do_signup(author: str) -> BotResponse:
    '''Registers a new user if they haven’t signed up yet.'''
    user_id = db.get_player(author)

    if user_id:
        return {
            'message': f'{author} 👀 You’re already signed up! Let the rolling \
begin~ 🎲',
            'attachment_urls': None
        }

    new_user_id = db.insert_player(author)
    return {
            'message': f'{author} ✅ Signed up successfully! Your gacha \
destiny begins now... ✨ Use the roll command to start!',
            'attachment_urls': None
        }


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(
        author: str,
        arguments: List[str],
        note_obj: Dict[str, Any]) -> BotResponse:
    '''Creates a card'''
    # 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'{author} You need an image to create a card, \
dumbass.',
            'attachment_urls': None
        }

    if not(len(arguments) in (2,5)):
        return {
            'message': f'{author} Please specify the following attributes \
in order: name, rarity. Optionally add [power, charm, wit].',
            'attachment_urls': None
        }

    if not (arguments[1].isnumeric() and 1 <= int(arguments[1]) <= 5):
        return {
            'message': f'{author} Invalid rarity: \'{arguments[1]}\' must \
be a number between 1 and 5',
            'attachment_urls': None
        }

    if len(arguments) == 2:
        pass
    else:
        if not all(arg.isnumeric() for arg in arguments[2:]):
            return {
                'message': f'{author} Invalid attributes: power, charm and \
wit must be numbers.',
                'attachment_urls': None
            }
        card_id, file_id = add_card(
        name=arguments[0],
        rarity=int(arguments[1]),
        image_url=image_url,
        power=int(arguments[2]),
        charm=int(arguments[3]),
        wit=int(arguments[4])
    )
        return {
        'message': f'{author} Added {arguments[0]}, ID {card_id}.',
        'attachment_urls': [file_id]
    }
    card_id, file_id = add_card(
        name=arguments[0],
        rarity=int(arguments[1]),
        image_url=image_url
    )
    return {
        'message': f'{author} Added {arguments[0]}, ID {card_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 card.\n\
- `create <name> <rarity>` Creates a card using a given image.\n\
- `signup` Registers your account.\n\
- `delete_account` Deletes your account.\n\
- `help` Shows this message',
        'attachment_urls': None
    }

# Dueling

def duel_request(author: str, args: list[str]) -> BotResponse:
    '''Sends a duel request to another user.'''
    if len(args) == 0:
        return {
            'message': f'{author} Please specify a user to duel.',
            'attachment_urls': None
        }

    target = args[0]
    if not db.get_player(target):
        return {
            'message': f'{author} User {target} does not exist or \
            has not signed up, please sign up before challenging to a duel.',
            'attachment_urls': None
        }
    if target == author:
        return {
            'message': f'{author} You can\'t duel yourself! \
            Try challenging someone else.',
            'attachment_urls': None
        }
    duel_type = 'casual'
    if len(args) == 1 and args[0] == "competitive":
        duel_type = 'competitive'

    db.insert_duel_request(author, target, duel_type)

    return {
        'message': f'{target} You have been challenged to a {duel_type} duel by \
        {author}! Reply with `accept_duel` to accept the challenge.',
        'attachment_urls': None
    }

def accept_duel(author: str, args: list[str]) -> BotResponse:
    '''Accepts a duel request from another user.'''
    if len(args) == 0:
        return {
            'message': f'{author} Please specify a user to accept the duel from.',
            'attachment_urls': None
        }

    target = args[0]
    if not db.get_player(target):
        return {
            'message': f'{author} User {target} does not exist or \
            has not signed up, please sign up before accepting a duel.',
            'attachment_urls': None
        }

    if db.accept_duel_request(author, target):
        return {
            'message': f'{author} You have accepted the duel request from {target}.',
            'attachment_urls': None
        }
    else:
        return {
            'message': f'{author} No duel request found from {target}.',
            'attachment_urls': None
        }

def delete_account(author: str) -> BotResponse:
    return {
        'message': f'{author} ⚠️ This will permanently delete your account \
and all your cards.\n'
        'If you\'re sure, reply with `confirm_delete_account` to proceed.\n\n'
        '**There is no undo.** Your gacha luck will be lost to the void... 💀✨',
        'attachment_urls': None

    }


def confirm_delete(author: str) -> BotResponse:
    db.delete_player(author)

    return {
        'message': f'{author} 🧼 Your account and all your cards have been \
deleted. RIP your gacha history 🕊️✨',
        'attachment_urls': None
    }


def do_whitelist(author: str, args: list[str]) -> BotResponse:
    if len(args) == 0:
        return {
            'message': f'{author} Please specify an instance to whitelist',
            'attachment_urls': None
        }

    if db.add_to_whitelist(args[0]):
        return {
            'message': f'{author} Whitelisted instance: {args[0]}',
            'attachment_urls': None
        }
    else:
        return {
            'message': f'{author} Instance already whitelisted: {args[0]}',
            'attachment_urls': None
        }


def do_unwhitelist(author: str, args: list[str]) -> BotResponse:
    if len(args) == 0:
        return {
            'message': f'{author} Please specify an instance to remove from \
the whitelist',
            'attachment_urls': None
        }

    if db.remove_from_whitelist(args[0]):
        return {
            'message': f'{author} Unwhitelisted instance: {args[0]}',
            'attachment_urls': None
        }
    else:
        return {
            'message': f'{author} Instance not whitelisted: {args[0]}',
            'attachment_urls': None
        }


def do_ban(author: str, args: list[str]) -> BotResponse:
    if len(args) == 0:
        return {
            'message': f'{author} Please specify a user to ban',
            'attachment_urls': None
        }

    if db.is_player_administrator(args[0]):
        return {
            'message': f'{author} Cannot ban other administrators.',
            'attachment_urls': None
        }

    if db.ban_player(args[0]):
        # Delete banned player's account
        db.delete_player(args[0])
        return {
            'message': f'{author} 🔨 **BONK!** Get banned, {args[0]}!',
            'attachment_urls': None
        }
    else:
        return {
            'message': f'{author} Player is already banned: {args[0]}',
            'attachment_urls': None
        }


def do_unban(author: str, args: list[str]) -> BotResponse:
    if len(args) == 0:
        return {
            'message': f'{author} Please specify a user to unban',
            'attachment_urls': None
        }

    if db.unban_player(args[0]):
        return {
            'message': f'{author} Player unbanned: {args[0]}!',
            'attachment_urls': None
        }
    else:
        return {
            'message': f'{author} Player was not banned: {args[0]}',
            '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
    author = notification['author']
    player_id = db.get_player(author)
    command = notification['command']

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

    # Commands beyond this point require the user to have an account
    if not player_id:
        return res

    # User commands
    match command:
        case 'create':
            res = do_create(
                author,
                notification['arguments'],
                notification['note_obj']
            )
        case 'delete_account':
            res = delete_account(author)
        case 'confirm_delete_account':
            res = confirm_delete(author)
        case 'duel_request':
            res = duel_request(
                author,
                notification['arguments']
            )
        case _:
            pass

    # Commands beyond this point require the user to be an administrator
    if not db.is_player_administrator(author):
        return res

    # Admin commands
    match command:
        case 'whitelist':
            res = do_whitelist(author, notification['arguments'])
        case 'unwhitelist':
            res = do_unwhitelist(author, notification['arguments'])
        case 'ban':
            res = do_ban(author, notification['arguments'])
        case 'unban':
            res = do_unban(author, notification['arguments'])
        case _:
            pass

    # Administrator commands go here
    return res
