utils_ui.py

from __future__ import annotations
import logging
import re
import io
from PIL import Image
import random

import discord
from discord.ext import commands
from discord.ui import Button, View, Select, Modal, TextInput
import asyncio

import DB
import AMP_Handler
import modules.banner_creator as BC
import utils


class ServerButton(Button):
    """Custom Start Button for when Servers are Offline."""

    def __init__(self, server: AMP_Handler.AMP.AMPInstance, view: discord.ui.View, function, label: str, callback_label: str, callback_disabled: bool, style=discord.ButtonStyle.green, context=None):
        super().__init__(label=label, style=style, custom_id=label)
        self.logger = logging.getLogger()
        self.server = server
        self.context = context
        self._label = label
        self.permission_node = 'server.' + self._label.lower()

        self.callback_label = callback_label
        self.callback_disabled = callback_disabled

        self._function = function
        self._view = view
        view.add_item(self)

    async def callback(self, interaction):
        """This is called when a button is interacted with."""
        if not await utils.async_rolecheck(interaction, self.permission_node):
            return
        self._interaction = interaction
        self.label = self.callback_label
        self.disabled = self.callback_disabled
        self._function()
        await interaction.response.edit_message(view=self._view)
        await asyncio.sleep(30)
        await self.reset()

    async def reset(self):
        self.logger.info('Resetting Buttons...')
        self.label = self._label
        self.disabled = False
        # server_embed = await self._view.update_view()
        await self._interaction.followup.edit_message(message_id=self._interaction.message.id, view=self._view)


class StartButton(ServerButton):
    def __init__(self, server, view, function):
        super().__init__(server=server, view=view, function=function, label='Start', callback_label='Starting...', callback_disabled=True, style=discord.ButtonStyle.green)


class StopButton(ServerButton):
    def __init__(self, server, view, function):
        super().__init__(server=server, view=view, function=function, label='Stop', callback_label='Stopping...', callback_disabled=True, style=discord.ButtonStyle.red)


class RestartButton(ServerButton):
    def __init__(self, server, view, function):
        super().__init__(server=server, view=view, function=function, label='Restart', callback_label='Restarting...', callback_disabled=True, style=discord.ButtonStyle.blurple)


class KillButton(ServerButton):
    def __init__(self, server, view, function):
        super().__init__(server=server, view=view, function=function, label='Kill', callback_label='Killed...', callback_disabled=True, style=discord.ButtonStyle.danger)


class StatusView(View):
    def __init__(self, timeout=180, context: commands.Context = None, amp_server: AMP_Handler.AMP.AMPInstance = None):
        super().__init__(timeout=timeout)
        self.server = amp_server
        self.context = context
        self.uBot = utils.botUtils()

    async def on_timeout(self):
        """This Removes all the Buttons after timeout has expired"""
        self.stop()


def banner_file_handler(image: Image.Image):
    with io.BytesIO() as image_binary:
        image.save(image_binary, 'PNG')
        image_binary.seek(0)
        return discord.File(fp=image_binary, filename='image.png')


class Edited_DB_Banner():
    """DB_Banner for Banner Editor"""

    def __init__(self, db_banner: DB.DBBanner):
        self._db_banner = db_banner

        self.invalid_keys = ['_db', 'ServerID', 'background_path']
        self.reset_db()

    def save_db(self):
        for key in self._db_banner.attr_list:
            if key in self.invalid_keys:
                continue

            if getattr(self._db_banner, key) != getattr(self, key):
                setattr(self._db_banner, key, getattr(self, key))

        return self._db_banner

    def reset_db(self):
        for key in self._db_banner.attr_list:
            if key in self.invalid_keys:
                continue
            setattr(self, key, getattr(self._db_banner, key))
        return self._db_banner


class Banner_Editor_View(View):
    def __init__(self, amp_server: AMP_Handler.AMP.AMPInstance, db_banner: DB.DBBanner, banner_message: discord.Message, timeout=None):
        self.logger = logging.getLogger()

        self._original_db_banner = db_banner
        self._edited_db_banner = Edited_DB_Banner(db_banner)
        self._banner_message = banner_message  # This is the message that the banner is attached to.
        self._amp_server = amp_server
        self._first_interaction = discord.Interaction
        self._first_interaction_bool = True

        self._banner_editor_select = Banner_Editor_Select(custom_id='banner_editor', edited_db_banner=self._edited_db_banner, banner_message=self._banner_message, view=self, amp_server=self._amp_server)
        super().__init__(timeout=timeout)
        self.add_item(self._banner_editor_select)
        self.add_item(Save_Banner_Button(banner_message=self._banner_message, edited_banner=self._edited_db_banner, server=self._amp_server))
        self.add_item(Reset_Banner_Button(banner_message=self._banner_message, edited_banner=self._edited_db_banner, server=self._amp_server))
        self.add_item(Cancel_Banner_Button(banner_message=self._banner_message))


class Banner_Editor_Select(Select):
    def __init__(self, edited_db_banner: Edited_DB_Banner, view: Banner_Editor_View, amp_server: AMP_Handler.AMP.AMPInstance, banner_message: discord.Message, custom_id: str = None, min_values: int = 1, max_values: int = 1, row: int = None, disabled: bool = False, placeholder: str = None):
        self.logger = logging.getLogger()
        options = []
        self._banner_view = view

        self._edited_db_banner = edited_db_banner
        self._banner_message = banner_message

        self._amp_server = amp_server

        whitelist_options = [
            discord.SelectOption(label="Whitelist Open Font Color", value='color_whitelist_open'),
            discord.SelectOption(label="Whitelist Closed Font Color", value='color_whitelist_closed')]
        donator_options = [
            discord.SelectOption(label="Donator Font Color", value='color_donator')]

        options = [
            discord.SelectOption(label="Blur Background Intensity", value='blur_background_amount'),
            discord.SelectOption(label="Header Font Color", value='color_header'),
            discord.SelectOption(label="Body Font Color", value='color_body'),
            discord.SelectOption(label="Host Font Color", value='color_host'),

            discord.SelectOption(label="Server Online Font Color", value='color_status_online'),
            discord.SelectOption(label="Server Offline Font Color", value='color_status_offline'),
            discord.SelectOption(label="Player Limit Minimum Font Color", value='color_player_limit_min'),
            discord.SelectOption(label="Player Limit Maximum Font Color", value='color_player_limit_max'),
            discord.SelectOption(label="Players Online Font Color", value='color_player_online')
        ]

        # If Whitelist is disabled, remove the options from the list.
        if not self._amp_server.Whitelist_disabled:
            options = whitelist_options + options

        # If Donator Only is enabled; adds the option to set the color.
        if self._amp_server.Donator:
            options = options + donator_options

        super().__init__(custom_id=custom_id, placeholder=placeholder, min_values=min_values, max_values=max_values, options=options, disabled=disabled, row=row)

    async def callback(self, interaction: discord.Interaction):
        if self.values[0] == 'blur_background_amount':
            input_type = 'int'
        else:
            input_type = 'color'

        self._banner_modal = Banner_Modal(input_type=input_type, title=f'{self.values[0].replace("_", " ")}', select_value=self.values[0], edited_db_banner=self._edited_db_banner, banner_message=self._banner_message, view=self._banner_view, amp_server=self._amp_server)
        await interaction.response.send_modal(self._banner_modal)

        self._first_interaction = False


class Banner_Modal(Modal):
    def __init__(self, input_type: str, select_value: str, title: str, view: Banner_Editor_View, edited_db_banner: Edited_DB_Banner, banner_message: discord.Message, amp_server: AMP_Handler.AMP.AMPInstance, timeout=None, custom_id='Banner Modal'):
        self._edited_db_banner = edited_db_banner
        self._banner_message = banner_message
        self._banner_view = view

        self._amp_server = amp_server

        self._select_value = select_value  # This is the Select Option Choice that was made.
        self._input_type = input_type
        super().__init__(title=title, timeout=timeout, custom_id=custom_id)

        if self._input_type == 'color':
            self._color_code_input = Banner_Color_Input(edited_db_banner=self._edited_db_banner, select_value=self._select_value, view=self._banner_view)
            self.add_item(self._color_code_input)

        if self._input_type == 'int':
            self._int_code_input = Banner_Blur_Input(edited_db_banner=self._edited_db_banner, select_value=self._select_value, view=self._banner_view)
            self.add_item(self._int_code_input)

    async def on_submit(self, interaction: discord.Interaction):
        # Depending on the Selection made; changes the validation code and the reply.
        if self._input_type == 'int':
            if await self._int_code_input.callback() == False:
                await interaction.response.send_message(f'Please provide a Number only. {self._int_code_input.value}', ephemeral=True, delete_after=self._client.Message_Timeout)

        if self._input_type == 'color':
            if await self._color_code_input.callback() == False:
                await interaction.response.send_message(content=f'Please provide a proper Hex color Code. {self._color_code_input._value}', ephemeral=True, delete_after=self._client.Message_Timeout)

        # Regardless we defer the interaction; because we only care if it fails as seen above.
        await interaction.response.defer()
        # Then we send the updated Banner object to the View.
        await self._banner_message.edit(attachments=[banner_file_handler(BC.Banner_Generator(self._amp_server, self._edited_db_banner)._image_())], view=self._banner_view)


class Banner_Color_Input(TextInput):
    # This is the Modal that appears when Inputing a color hexcode.
    def __init__(self, view: Banner_Editor_View, edited_db_banner: Edited_DB_Banner, select_value: str, label: str = "Enter your Hex color code below.", style=discord.TextStyle.short, placeholder: str = '#000000', default: str = '#ffffff', required=True, min_length=3, max_length=8):
        self._edited_db_banner = edited_db_banner
        self._select_value = select_value
        self._banner_view = view
        super().__init__(label=label, style=style, placeholder=placeholder, default=default, required=required, min_length=min_length, max_length=max_length)

    async def callback(self):
        # Remove the Hex code for validation.
        # Also lower the value for better comparison.
        self._value = self.value.lower()
        if self._value[0] == '#':
            self._value = self._value[1:]

        # Validate if Hex Color Code.
        if len(self._value) in [3, 4, 6, 8] and re.search(f'([0-9a-f]{{{len(self._value)}}})$', self._value):
            self._banner_view.logger.dev(f'Set attr for {self._edited_db_banner} {self._select_value} #{self._value}')
            setattr(self._edited_db_banner, self._select_value, '#' + self._value)
            return True

        else:
            return False


class Banner_Blur_Input(TextInput):
    # This is the Modal that appears when inputing the blur value.
    def __init__(self, view: Banner_Editor_View, edited_db_banner: Edited_DB_Banner, select_value: str, label: str = "Blur Background Intensity", style=discord.TextStyle.short, placeholder='Enter a Number', default: int = 2, required=True, min_length=1, max_length=2):
        self._edited_db_banner = edited_db_banner
        self._select_value = select_value
        self._banner_view = view
        super().__init__(label=label, style=style, placeholder=placeholder, default=default, required=required, min_length=min_length, max_length=max_length)

    async def callback(self):
        if self.value.isnumeric() and int(self.value) <= 99:
            self._banner_view.logger.dev(f'Set attr for {self._edited_db_banner} {self._select_value} {self.value}')
            setattr(self._edited_db_banner, self._select_value, int(self.value[0]))
            return True
        else:
            return False


class Save_Banner_Button(Button):
    """Saves the Banners current settings to the DB."""

    def __init__(self, banner_message: discord.Message, server: AMP_Handler.AMP.AMPInstance, edited_banner: Edited_DB_Banner, style=discord.ButtonStyle.green):
        super().__init__(label='Save', style=style, custom_id='Save_Button')
        self.logger = logging.getLogger()
        self._amp_server = server
        self._banner_message = banner_message
        self._edited_db_banner = edited_banner

    async def callback(self, interaction: discord.Interaction):
        """This is called when a button is interacted with."""
        saved_banner = self._edited_db_banner.save_db()
        await interaction.response.defer()
        file = banner_file_handler(BC.Banner_Generator(self._amp_server, saved_banner)._image_())
        await self._banner_message.edit(content='**Banner Settings have been saved.**', attachments=[file], view=None)


class Reset_Banner_Button(Button):
    """Resets the Banners current settings to the original DB."""

    def __init__(self, banner_message: discord.Message, server: AMP_Handler.AMP.AMPInstance, edited_banner: Edited_DB_Banner, style=discord.ButtonStyle.blurple):
        super().__init__(label='Reset', style=style, custom_id='Reset_Button')
        self.logger = logging.getLogger()
        self._amp_server = server
        self._banner_message = banner_message
        self._edited_db_banner = edited_banner

    async def callback(self, interaction: discord.Interaction):
        """This is called when a button is interacted with."""
        saved_banner = self._edited_db_banner.reset_db()
        await interaction.response.defer()
        file = banner_file_handler(BC.Banner_Generator(self._amp_server, saved_banner)._image_())
        await self._banner_message.edit(content='**Banner Settings have been reset.**', attachments=[file])


class Cancel_Banner_Button(Button):
    """Cancels the Banner Settings View"""

    def __init__(self, banner_message: discord.Message, style=discord.ButtonStyle.red):
        super().__init__(label='Cancel', style=style, custom_id='Cancel_Button')
        self.logger = logging.getLogger()
        self._banner_message = banner_message

    async def callback(self, interaction: discord.Interaction):
        """This is called when a button is interacted with."""
        await interaction.response.defer()
        await self._banner_message.edit(content='**Banner Settings Editor has been Cancelled.**', attachments=[], view=None)


class Whitelist_view(View):
    """Whitelist Request View"""

    def __init__(self, client: discord.Client, discord_message: discord.Message, whitelist_message: discord.Message, amp_server: AMP_Handler.AMP.AMPInstance, context: commands.Context, timeout: float = None):
        self.logger = logging.getLogger()
        self.DB = DB.getDBHandler().DB
        self._client = client
        self._context = context
        self._whitelist_message = whitelist_message
        self._amp_server = amp_server

        # This is for when Auto-Whitelisting is Disabled to prevent the View from timing out...
        if timeout != None:
            # Converts my Minutes value I pass in into seconds which is what `Views` rely on..
            timeout = (timeout * 60)

        super().__init__(timeout=timeout)
        self.add_item(Accept_Whitelist_Button(discord_message=discord_message, view=self, client=client, amp_server=amp_server))
        self.add_item(Deny_Whitelist_Button(discord_message=discord_message, view=self, client=client, amp_server=amp_server))

    async def _whitelist_handler(self):
        db_server = self.DB.GetServer(self._amp_server.InstanceID)
        self.logger.dev(f'Whitelist Request; Attempting to Whitelist {self._whitelist_message.author.name} on {db_server.FriendlyName}')
        # This handles all the Discord Role stuff.
        if db_server != None and db_server.Discord_Role != None:
            discord_role = self._client.uBot.role_parse(db_server.Discord_Role, self._context, self._context.guild.id)
            discord_user = self._client.uBot.user_parse(self._context.author.id, self._context, self._context.guild.id)
            await discord_user.add_roles(discord_role, reason='Auto Whitelisting')

        # This is for all the Replies
        if len(self.DB.GetAllWhitelistReplies()) != 0:
            whitelist_reply = random.choice(self.DB.GetAllWhitelistReplies())
            await self._context.message.channel.send(content=f'{self._context.author.mention} \n{self._client.uBot.whitelist_reply_handler(message= whitelist_reply, context= self._context, server= self._amp_server)}', delete_after=self._client.Message_Timeout)
        else:
            await self._context.message.channel.send(content=f'You are all set! We whitelisted {self._context.author.mention} on **{db_server.FriendlyName}**', delete_after=self._client.Message_Timeout)


class Accept_Whitelist_Button(Button):
    """Accepts the Whitelist Request"""

    def __init__(self, discord_message: discord.Message, view: Whitelist_view, client: discord.Client, amp_server: AMP_Handler.AMP.AMPInstance, style=discord.ButtonStyle.green):
        super().__init__(label='Accept', style=style, custom_id='Accept_Button')
        self._view = view
        self._discord_message = discord_message
        self._amp_server = amp_server
        self._client = client

    async def callback(self, interaction: discord.Interaction):
        if await utils.async_rolecheck(context=interaction, perm_node='whitelist_buttons'):
            self._view.logger.info(f'We Accepted a Whitelist Request by {self._view._whitelist_message.author.name}')
            await self._discord_message.edit(content=f'**{interaction.user.name}** -> Approved __{self._view._whitelist_message.author.name}__ Whitelist Request', view=None)
            await self._view._whitelist_handler()
            self._amp_server.addWhitelist(self._client.Whitelist_wait_list[self._view._whitelist_message.id]['dbuser'])
            self._client.Whitelist_wait_list.pop(self._view._whitelist_message.id)
            self.disabled = True


class Deny_Whitelist_Button(Button):
    """Denys the Whitelist Request"""

    def __init__(self, discord_message: discord.Message, view: Whitelist_view, client: discord.Client, amp_server: AMP_Handler.AMP.AMPInstance, style=discord.ButtonStyle.red):
        super().__init__(label='Deny', style=style, custom_id='Deny_Button')
        self._view = view
        self._discord_message = discord_message
        self._amp_server = amp_server
        self._client = client

    async def callback(self, interaction: discord.Interaction):
        if await utils.async_rolecheck(context=interaction, perm_node='whitelist_buttons'):
            self._view.logger.info(f'We Denied a Whitelist Request by {self._view._whitelist_message.author.name}')
            await self._discord_message.edit(content=f'**{interaction.user.name}** -> Denied __{self._view._whitelist_message.author.name}__ Whitelist Request', view=None)
            await self._view._whitelist_message.channel.send(content=f'**{interaction.user.name}** Denied {self._view._whitelist_message.author.mention} whitelist request. Please contact a Staff Member.')
            self._client.Whitelist_wait_list.pop(self._view._whitelist_message.id)
            self.disabled = True


class DB_Instance_ID_Swap(View):
    """DB Instance ID Swap View"""

    def __init__(self, discord_message: discord.Message, timeout: float, from_db_server: DB.DBServer, to_db_server: DB.DBServer):
        super().__init__(timeout=timeout)
        self._from_db_server = from_db_server
        self._to_db_server = to_db_server
        self.add_item(Approve_Button(view=self, discord_message=discord_message))
        self.add_item(Cancel_Button(view=self, discord_message=discord_message))


class Approve_Button(Button):
    def __init__(self, view: View, discord_message: discord.Message, style=discord.ButtonStyle.green):
        self._view = view
        self.message = discord_message
        super().__init__(label='Approve', style=style, custom_id='Approve_Button')

    async def callback(self, interaction: discord.Interaction):
        to_db_server_ID = self._view._to_db_server.InstanceID
        to_db_server_Name = self._view._to_db_server.InstanceName
        self._view._to_db_server.delServer()
        self._view._from_db_server.InstanceID = to_db_server_ID
        await self.message.edit(content=f'Replaced **{self._view._from_db_server.InstanceName} ID: {self._view._from_db_server.InstanceID}** with **{to_db_server_Name} ID: {to_db_server_ID}**', view=None)


class Cancel_Button(Button):
    def __init__(self, view: View, discord_message: discord.Message, style=discord.ButtonStyle.red):
        self._view = view
        self.message = discord_message
        super().__init__(label='Cancel', style=style, custom_id='Cancel_Button')

    async def callback(self, interaction: discord.Interaction):
        return await self.message.edit(content=f'Cancelling change of **{self._view._from_db_server.InstanceName}** Instance ID. ', view=None)