from asyncio import sleep
from typing import List

import disnake
from disnake import Option, OptionType, OptionChoice

from disnake.ext import commands, tasks

from lib import read_json, write_json
from lib import fill_bd, prepare_db, work_with_db
from lib import logger


class Admin(commands.Cog, name='Admin'):
    def __init__(self, bot):
        self.bot = bot  # a defining bot as global var in class

    @commands.Cog.listener()  # this is a decorator for events/listeners
    async def on_ready(self):
        for g in self.bot.get_all_members():
            await prepare_db(g.guild.id)
        for g in self.bot.get_all_members():
            await fill_bd(g.name, g.id, g.bot, g.nick, g.guild.id)

        self.activity.start()
        logger.info(f'Cog {__name__.split(".")[1]} is ready!.')

    @tasks.loop(seconds=20)
    async def activity(self):
        await self.bot.change_presence(
            activity=disnake.Activity(
                name=f'at users: {str(len(self.bot.users))}',
                type=3
            )
        )
        await sleep(10)
        await self.bot.change_presence(
            activity=disnake.Activity(
                name=f'at servers: {str(len(self.bot.guilds))}',
                type=3
            )
        )

    @commands.Cog.listener()
    async def on_member_update(self, before: disnake.Member, after: disnake.Member):
        sql_update_query = f"""UPDATE "{after.guild.id}" set nick = ? where userid = ?"""
        data_tuple = (after.nick, before.id)
        await work_with_db(sql_update_query, data_tuple)

    @commands.Cog.listener()
    async def on_guild_join(self, guild):
        for g in guild.members:
            await fill_bd(g.name, g.id, g.bot, g.nick, guild.id)

    @commands.Cog.listener()
    async def on_member_join(self, member):
        await fill_bd(member.name, member.id, member.bot, member.nick, member.guild.id)

        bot_role = read_json(member.guild.id, 'bot_role')  # Get bot role
        guest_role = read_json(member.guild.id, 'guest_role')  # Get guest role

        if bot_role or guest_role:
            if member.bot == 0:
                role = disnake.utils.get(member.guild.roles, id=guest_role)
            else:
                role = disnake.utils.get(member.guild.roles, id=bot_role)
            logger.info(f"Adding to {member} role {role}")
            await member.add_roles(role)

    @commands.slash_command(
        name="set_guest_role",
        description="Set Default bot role",
        options=[
            Option("role", "Specify role", OptionType.role, required=True),
        ]
    )
    @commands.has_permissions(administrator=True)
    async def set_guest_role(self, inter, role):
        await write_json(inter.guild.id, "guest_role", role.id)
        await inter.response.send_message(f"Set up bot role to: `{role.name}`", ephemeral=True)

    @commands.command(name="set_prefix")
    @commands.has_permissions(administrator=True)
    async def command_set_prefix(self, ctx, prefix: str):
        await write_json(ctx.guild.id, "prefix", prefix)
        await ctx.reply(f"Prefix set to: `{prefix}`")

    @commands.guild_only()
    @commands.slash_command(
        name="set_prefix",
        description="Setting up bot prefix",
        options=[
            Option("prefix", "Specify prefix", OptionType.string, required=True),
        ]
    )
    @commands.has_permissions(administrator=True)
    async def slash_set_prefix(self, inter, prefix: str):
        await write_json(inter.guild.id, "prefix", prefix)
        await inter.response.send_message(f"Prefix set to: `{prefix}`", ephemeral=True)

    @commands.guild_only()
    @commands.slash_command(
        name="set_trigger_role",
        description="Setting up role to trigger bot",
        options=[
            Option("role", "Specify role", OptionType.role, required=True),
        ]
    )
    @commands.has_permissions(administrator=True)
    async def set_trigger_role(self, inter, role):
        await write_json(inter.guild.id, "tigger_role", role.id)
        await inter.response.send_message(f"Role to trigger set to : `{role.name}`", ephemeral=True)

    @commands.slash_command(
        name="set_bot_role",
        description="Set Default bot role",
        options=[
            Option("role", "Specify role", OptionType.role, required=True),
        ]
    )
    @commands.guild_only()
    @commands.has_permissions(administrator=True)
    async def set_bot_role(self, ctx, role):
        await write_json(ctx.guild.id, "bot_role", role.id)
        await ctx.send(f"Set up bot role to: `{role.name}`", ephemeral=True)

    @set_bot_role.error
    @set_trigger_role.error
    @slash_set_prefix.error
    async def set_prefix_error(self, inter, prefix):
        await inter.response.send_message("You don`t have permissions", ephemeral=True)

    @commands.has_permissions(administrator=True)
    @commands.slash_command(
        name="set_time",
        description="Read list of tracks for user",
        options=[
            Option("seconds", "specify max duration", OptionType.integer, required=True),
        ]
    )
    async def set_time(self,
                       inter: disnake.ApplicationCommandInteraction,
                       seconds: commands.Range[5, 30]):
        await write_json(inter.guild.id, "seconds", seconds)
        await inter.response.send_message(f"Change max audio duration to {seconds} sec", ephemeral=True)

    @commands.has_permissions(administrator=True)
    @commands.slash_command(
        name="set_bot_channel",
        description="Set channel which iterate with bot",
        options=[
            Option("channel", "specify channel", OptionType.string, required=True),
        ]
    )
    async def set_bot_channel(self, inter, channel):
        print(type(inter.guild.text_channels))
        await write_json(inter.guild.id, "channel", channel.id)
        await inter.response.send_message(f"Channel set up to {channel.mention}", ephemeral=True)

    @set_bot_channel.autocomplete('channel')
    async def _list_text_channels(self,
                                  inter: disnake.ApplicationCommandInteraction,
                                  current: str) -> List[OptionChoice]:
        _list = []
        for _channel in inter.guild.text_channels:
            _list.append(_channel)
        return [
            OptionChoice(name=choice, value=choice)
            for choice in _list if current in choice
        ]


def setup(bot):  # an extension must have a setup function
    bot.add_cog(Admin(bot))  # adding a cog