from typing import Any, Optional

import discord
from babel.translator import ctx_translator
from core.data import CoreData
from core.setting_types import MessageSetting
from meta import LionBot
from settings import ListData, ModelData
from settings.groups import SettingGroup
from settings.setting_types import BoolSetting, ChannelSetting, RoleListSetting
from utils.lib import recurse_map, replace_multiple, tabulate
from wards import low_management_iward, high_management_iward

from . import babel
from .data import MemberAdminData

_p = babel._p

_greeting_subkey_desc = {
    '{mention}': _p('guildset:greeting_message|formatkey:mention',
                    "Mention the new member."),
    '{user_name}': _p('guildset:greeting_message|formatkey:user_name',
                      "Display name of the new member."),
    '{user_avatar}': _p('guildset:greeting_message|formatkey:user_avatar',
                        "Avatar url of the new member."),
    '{guild_name}': _p('guildset:greeting_message|formatkey:guild_name',
                       "Name of this server."),
    '{guild_icon}': _p('guildset:greeting_message|formatkey:guild_icon',
                       "Server icon url."),
    '{studying_count}': _p('guildset:greeting_message|formatkey:studying_count',
                           "Number of current voice channel members."),
    '{member_count}': _p('guildset:greeting_message|formatkey:member_count',
                         "Number of members in the server."),
}


class MemberAdminSettings(SettingGroup):
    class GreetingChannel(ModelData, ChannelSetting):
        setting_id = 'greeting_channel'
        _write_ward = low_management_iward

        _display_name = _p('guildset:greeting_channel', "welcome_channel")
        _desc = _p(
            'guildset:greeting_channel|desc',
            "Channel in which to welcome new members to the server."
        )
        _long_desc = _p(
            'guildset:greeting_channel|long_desc',
            "New members will be sent the configured `welcome_message` in this channel, "
            "and returning members will be sent the configured `returning_message`. "
            "Unset to send these message via direct message."
        )
        _accepts = _p(
            'guildset:greeting_channel|accepts',
            "Name or id of the greeting channel, or 0 for DM."
        )

        _model = CoreData.Guild
        _column = CoreData.Guild.greeting_channel.name
        _allow_object = False

        @property
        def update_message(self) -> str:
            t = ctx_translator.get().t
            value = self.value
            if value is None:
                # Greetings will be sent via DM
                resp = t(_p(
                    'guildset:greeting_channel|set_response:unset',
                    "Welcome messages will now be sent via direct message."
                ))
            else:
                resp = t(_p(
                    'guildset:greeting_channel|set_response:set',
                    "Welcome messages will now be sent to {channel}"
                )).format(channel=value.mention)
            return resp

        @classmethod
        def _format_data(cls, parent_id, data, **kwargs):
            t = ctx_translator.get().t
            if data is not None:
                return f"<#{data}>"
            else:
                return t(_p(
                    'guildset:greeting_channel|formmatted:unset',
                    "Direct Message"
                ))

    class GreetingMessage(ModelData, MessageSetting):
        setting_id = 'greeting_message'
        _write_ward = low_management_iward

        _display_name = _p(
            'guildset:greeting_message', "welcome_message"
        )
        _desc = _p(
            'guildset:greeting_message|desc',
            "Custom message used to greet new members when they join the server."
        )
        _long_desc = _p(
            'guildset:greeting_message|long_desc',
            "When set, this message will be sent to the `welcome_channel` when a *new* member joins the server. "
            "If not set, no message will be sent."
        )
        _accepts = _p(
            'guildset:greeting_message|accepts',
            "JSON formatted greeting message data"
        )
        _soft_default = _p(
            'guildset:greeting_message|default',
            r"""
            {
                "embed": {
                    "title": "Welcome {user_name}!",
                    "thumbnail": {"url": "{user_avatar}"},
                    "description": "Welcome to **{guild_name}**!",
                    "footer": {
                        "text": "You are the {member_count}th member!"
                    },
                    "color": 15695665
                }
            }
            """
        )

        _model = CoreData.Guild
        _column = CoreData.Guild.greeting_message.name

        _subkey_desc = _greeting_subkey_desc

        @property
        def update_message(self) -> str:
            t = ctx_translator.get().t
            value = self.value
            if value is None:
                # No greetings
                resp = t(_p(
                    'guildset:greeting_message|set_response:unset',
                    "Welcome message unset! New members will not be greeted."
                ))
            else:
                resp = t(_p(
                    'guildset:greeting_message|set_response:set',
                    "The welcome message has been updated."
                ))
            return resp

        @classmethod
        def _format_data(cls, parent_id, data, **kwargs):
            t = ctx_translator.get().t
            if data is not None:
                return super()._format_data(parent_id, data, **kwargs)
            else:
                return t(_p(
                    'guildset:greeting_message|formmatted:unset',
                    "Not set, members will not be welcomed."
                ))

        @classmethod
        async def generate_formatter(cls, bot: LionBot, member: discord.Member, **kwargs):
            """
            Generate a formatter function for this message from the given context.

            The formatter function both accepts and returns a message data dict.
            """
            async def formatter(data_dict: Optional[dict[str, Any]]):
                if not data_dict:
                    return None

                guild = member.guild
                active = sum(1 for ch in guild.voice_channels for member in ch.members)
                mapping = {
                    '{mention}': member.mention,
                    '{user_name}': member.display_name,
                    '{user_avatar}': member.avatar.url if member.avatar else member.default_avatar.url,
                    '{guild_name}': guild.name,
                    '{guild_icon}': guild.icon.url if guild.icon else member.default_avatar.url,
                    '{studying_count}': str(active),
                    '{member_count}': guild.member_count,
                }

                recurse_map(
                    lambda loc, value: replace_multiple(value, mapping) if isinstance(value, str) else value,
                    data_dict,
                )

                return data_dict
            return formatter

        async def editor_callback(self, editor_data):
            self.value = editor_data
            await self.write()

        def _desc_table(self, show_value: Optional[str] = None) -> list[tuple[str, str]]:
            lines = super()._desc_table(show_value=show_value)
            t = ctx_translator.get().t
            keydescs = [
                (key, t(value)) for key, value in self._subkey_desc.items()
            ]
            keytable = tabulate(*keydescs, colon='')
            expline = t(_p(
                'guildset:greeting_message|embed_field|formatkeys|explanation',
                "The following placeholders will be substituted with their values."
            ))
            keyfield = (
                t(_p('guildset:greeting_message|embed_field|formatkeys|name', "Placeholders")),
                expline + '\n' + '\n'.join(f"> {line}" for line in keytable)
            )
            lines.append(keyfield)
            return lines

    class ReturningMessage(ModelData, MessageSetting):
        setting_id = 'returning_message'
        _write_ward = low_management_iward

        _display_name = _p(
            'guildset:returning_message', "returning_message"
        )
        _desc = _p(
            'guildset:returning_message|desc',
            "Custom message used to greet returning members when they rejoin the server."
        )
        _long_desc = _p(
            'guildset:returning_message|long_desc',
            "When set, this message will be sent to the `welcome_channel` when a member *returns* to the server. "
            "If not set, no message will be sent."
        )
        _accepts = _p(
            'guildset:returning_message|accepts',
            "JSON formatted returning message data"
        )
        _soft_default = _p(
            'guildset:returning_message|default',
            r"""
            {
                "embed": {
                    "title": "Welcome Back {user_name}!",
                    "thumbnail": {"url": "{User_avatar}"},
                    "description": "Welcome back to **{guild_name}**!\nYou were last seen <t:{last_time}:R>.",
                    "color": 15695665
                }
            }
            """
        )

        _model = CoreData.Guild
        _column = CoreData.Guild.returning_message.name

        _subkey_desc_returning = {
            '{last_time}': _p('guildset:returning_message|formatkey:last_time',
                              "Unix timestamp of the last time the member was seen in the server.")
        }
        _subkey_desc = _greeting_subkey_desc | _subkey_desc_returning

        @property
        def update_message(self) -> str:
            t = ctx_translator.get().t
            value = self.value
            if value is None:
                resp = t(_p(
                    'guildset:returning_message|set_response:unset',
                    "Returning member greeting unset! Will use `welcome_message` if set."
                ))
            else:
                resp = t(_p(
                    'guildset:greeting_message|set_response:set',
                    "The returning member greeting has been updated."
                ))
            return resp

        @classmethod
        def _format_data(cls, parent_id, data, **kwargs):
            t = ctx_translator.get().t
            if data is not None:
                return super()._format_data(parent_id, data, **kwargs)
            else:
                return t(_p(
                    'guildset:greeting_message|formmatted:unset',
                    "Not set, will use the `welcome_message` if set."
                ))

        @classmethod
        async def generate_formatter(cls, bot: LionBot,
                                     member: discord.Member, last_seen: Optional[int],
                                     **kwargs):
            """
            Generate a formatter function for this message from the given context.

            The formatter function both accepts and returns a message data dict.
            """
            async def formatter(data_dict: Optional[dict[str, Any]]):
                if not data_dict:
                    return None

                guild = member.guild
                active = sum(1 for ch in guild.voice_channels for member in ch.members)
                mapping = {
                    '{mention}': member.mention,
                    '{user_name}': member.display_name,
                    '{user_avatar}': member.avatar.url if member.avatar else member.default_avatar.url,
                    '{guild_name}': guild.name,
                    '{guild_icon}': guild.icon.url if guild.icon else member.default_avatar.url,
                    '{studying_count}': str(active),
                    '{member_count}': str(guild.member_count),
                    '{last_time}': str(last_seen or member.joined_at.timestamp()),
                }

                recurse_map(
                    lambda loc, value: replace_multiple(value, mapping) if isinstance(value, str) else value,
                    data_dict,
                )

                return data_dict
            return formatter

        async def editor_callback(self, editor_data):
            self.value = editor_data
            await self.write()

        def _desc_table(self, show_value: Optional[str] = None) -> list[tuple[str, str]]:
            lines = super()._desc_table(show_value=show_value)
            t = ctx_translator.get().t
            keydescs = [
                (key, t(value)) for key, value in self._subkey_desc_returning.items()
            ]
            keytable = tabulate(*keydescs, colon='')
            expline = t(_p(
                'guildset:returning_message|embed_field|formatkeys|explanation',
                "In *addition* to the placeholders supported by `welcome_message`"
            ))
            keyfield = (
                t(_p('guildset:returning_message|embed_field|formatkeys|', "Placeholders")),
                expline + '\n' + '\n'.join(f"> {line}" for line in keytable)
            )
            lines.append(keyfield)
            return lines


    class Autoroles(ListData, RoleListSetting):
        setting_id = 'autoroles'
        _write_ward = high_management_iward

        _display_name = _p(
            'guildset:autoroles', "autoroles"
        )
        _desc = _p(
            'guildset:autoroles|desc',
            "Roles given to new members when they join the server."
        )
        _long_desc = _p(
            'guildset:autoroles|long_desc',
            "These roles will be given when a member joins the server. "
            "If `role_persistence` is enabled, these roles will *not* be given to a returning member."
        )

        _table_interface = MemberAdminData.autoroles
        _id_column = 'guildid'
        _data_column = 'roleid'
        _order_column = 'roleid'


    class BotAutoroles(ListData, RoleListSetting):
        setting_id = 'bot_autoroles'
        _write_ward = high_management_iward

        _display_name = _p(
            'guildset:bot_autoroles', "bot_autoroles"
        )
        _desc = _p(
            'guildset:bot_autoroles|desc',
            "Roles given to new bots when they join the server."
        )
        _long_desc = _p(
            'guildset:bot_autoroles|long_desc',
            "These roles will be given when a bot joins the server."
        )


        _table_interface = MemberAdminData.bot_autoroles
        _id_column = 'guildid'
        _data_column = 'roleid'
        _order_column = 'roleid'

    class RolePersistence(ModelData, BoolSetting):
        setting_id = 'role_persistence'
        _event = 'guildset_role_persistence'
        _write_ward = low_management_iward

        _display_name = _p('guildset:role_persistence', "role_persistence")
        _desc = _p(
            'guildset:role_persistence|desc',
            "Whether member roles should be restored on rejoin."
        )
        _long_desc = _p(
            'guildset:role_persistence|long_desc',
            "If enabled, member roles will be stored when they leave the server, "
            "and then restored when they rejoin (instead of giving `autoroles`). "
            "Note that this may conflict with other bots who manage join roles."
        )
        _default = True

        _model = CoreData.Guild
        _column = CoreData.Guild.persist_roles.name

        @property
        def update_message(self) -> str:
            t = ctx_translator.get().t
            value = self.value
            if not value:
                resp = t(_p(
                    'guildset:role_persistence|set_response:off',
                    "Roles will not be restored when members rejoin."
                ))
            else:
                resp = t(_p(
                    'guildset:greeting_message|set_response:on',
                    "Roles will now be restored when members rejoin."
                ))
            return resp

    guild_model_settings = (
        GreetingChannel,
        GreetingMessage,
        ReturningMessage,
        RolePersistence,
    )