import disnake
from disnake.ext import commands
from disnake.enums import ButtonStyle
from env import *
from database import *
from datetime import datetime, date
from dateutil import relativedelta
import re
# @todo fix image remove logging


class log_to_server(commands.Cog):
    def __init__(self, bot: commands.Bot):
        self.bot = bot


    # Member guild
    @commands.Cog.listener()
    async def on_member_join(self, member):
        print("Welcome! ", member)
        await log_to_server.member_guild_embed(self, member, type="joinde de keet!")
        await log_to_server.welcome_msg_member(self, member)

    @commands.Cog.listener()
    async def on_member_remove(self, member):
        print("Aaaah! er is een member/memberina weg!")
        await log_to_server.member_guild_embed(self, member, type="verliet de keet!")

    @commands.Cog.listener()
    async def on_member_ban(self, guild, member):
        print(f"Aaaah! User: {member} is gebanned van guild: {guild}.")
        await log_to_server.member_guild_embed(self, member, type="is verbannen van deze keet!")

    @commands.Cog.listener()
    async def on_member_unban(self, guild, member):
        print(f"Aaaah! User: {member} is gebanned van guild: {guild}.")
        await log_to_server.member_guild_embed(self, member, type="is un-banned van deze keet!")

    @commands.Cog.listener()
    async def on_member_update(self, before, after):
        if before.nick != after.nick:
                name_before = before.nick
                name_after = after.nick
                await log_to_server.user_name_change(self, name_before, name_after)


    # Voice
    @commands.Cog.listener()
    async def on_voice_state_update(self, member, before, after):
        # member joins voice
        if before.channel is None and after.channel is not None:
            await log_to_server.log_voice_state(self, member, vc_channel=after.channel, type="Joinde")
        # Member leaves voice
        elif after.channel is None and before.channel is not None:
            await log_to_server.log_voice_state(self, member, vc_channel=before.channel, type="Verliet")
        # Member switches voice channels
        elif before.channel != after.channel:
            await log_to_server.log_voice_state(self, member, vc_channel=after.channel, type="Veranderde")


    # Messages in guild
    @commands.Cog.listener()
    async def on_message_delete(self, payload):
        print(payload)
        await log_to_server.message_deleted(self, payload, message=payload.content, channel=payload.channel)

    @commands.Cog.listener()
    async def on_raw_bulk_message_delete(self, messages):
        bulk_deleted_count = len(messages.message_ids)
        bulk_deleted_channel = messages.channel_id
        await log_to_server.message_bulk_deleted(self, count=bulk_deleted_count, channel=bulk_deleted_channel)

    @commands.Cog.listener()
    async def on_message_edit(self, before, after):
        channel = after.channel.mention
        author = before.author
        if before.clean_content != after.clean_content:
            before_content = before.clean_content
            after_content = after.clean_content
            await log_to_server.message_edited(self, before_content, after_content, channel, author)

    @commands.Cog.listener()
    async def on_audit_log_entry_create(self, audit_entry):
        if "AuditLogAction.message_delete" in str(audit_entry):
            async for entry in audit_entry.guild.audit_logs(limit=1,action=disnake.AuditLogAction.message_delete):
                deleter = entry.user
                print(f"{deleter} deleted message by {audit_entry}")



    # Changes in guild and roles
    @commands.Cog.listener()
    async def on_guild_role_create(self, role):
        await log_to_server.new_or_deleted_role(self, role, type="aangemaakt")

    @commands.Cog.listener()
    async def on_guild_role_delete(self, role):
        await log_to_server.new_or_deleted_role(self, role, type="verwijderd")

    @commands.Cog.listener()
    async def on_guild_role_update(self, before, after):
        if before.name != after.name:
            await log_to_server.edited_role(self, before, after)

        elif before.color != after.color:
            await log_to_server.color_change_role(self, before, after)



    # Channels
    @commands.Cog.listener()
    async def on_guild_channel_create(self, channel):
        await log_to_server.channel_change(self, channel, type="Nieuw kanaal")

    @commands.Cog.listener()
    async def on_guild_channel_delete(self, channel):
        await log_to_server.channel_change(self, channel, type="Kanaal verwijderd")

    @commands.Cog.listener()
    async def on_guild_channel_update(self, before, after):
        if before.name != after.name:
            await log_to_server.channel_name_change(self, before=before.name, after=after.name)



    # LOG EMBEDS functions
    async def welcome_msg_member(self, member):

        channel = self.bot.get_channel(int(env_variable.WELCOME_CHANNEL))
        Database.cursor.execute("SELECT content FROM configuration_text WHERE service='welcome_text' LIMIT 1")

        res = Database.cursor.fetchone()[0]
        member_mentiont = member.mention
        await channel.send(res.format(member_mentiont))


    async def member_guild_embed(self, member, type):

        date_created_at = str(member.created_at).split(" ")[0]
        x = date_created_at.split("-")

        # get two dates
        d1 = f'{x[2]}/{x[1]}/{x[0]}'
        d2 = datetime.today().strftime('%d/%m/%Y')

        start_date = datetime.strptime(d1, "%d/%m/%Y")
        end_date = datetime.strptime(d2, "%d/%m/%Y")

        # Get the relativedelta between two dates
        delta = relativedelta.relativedelta(end_date, start_date)
        if str(delta.years) == "0":
            i = f"{delta.months} maanden en {delta.days} dagen"
        else:
            i = f"{delta.years} jaar,  {delta.months} maanden en {delta.days} dagen"

        embed=disnake.Embed(title="\n", description=f"**{member.mention} {type}**", color=disnake.Color.dark_green())
        embed.set_author(name=member, icon_url=member.avatar)
        embed.add_field(name="Account leeftijd:", value=str(i), inline=False)
        channel_to_send = self.bot.get_channel(env_variable.ADJE_LOG_CHANNEL_ID)
        await channel_to_send.send(embed=embed)



    # Member username change
    async def user_name_change(self, name_before, name_after):

        embed=disnake.Embed(title=f"Server gebruikersnaam bewerkt", description=f"\n", color=disnake.Color.purple())
        embed.add_field(name="Voor het bewerken:", value=str(name_before), inline=False)
        embed.add_field(name="Na het bewerken:", value=str(name_after), inline=False)
        channel_to_send = self.bot.get_channel(env_variable.ADJE_LOG_CHANNEL_ID)
        await channel_to_send.send(embed=embed)



    # Voice logging
    async def log_voice_state(self, member, vc_channel, type):
        embed=disnake.Embed(title=f"\n", description=f"**{member.mention} {type} voice kanaal: #{vc_channel}**", color=disnake.Color.greyple())
        embed.set_author(name=member, icon_url=member.avatar)
        channel_to_send = self.bot.get_channel(env_variable.ADJE_LOG_CHANNEL_ID)
        await channel_to_send.send(embed=embed)



    # Message
    async def message_deleted(self, payload, message, channel):

        embed=disnake.Embed(title=f"\n", description=f"{payload.author.mention} verwijderde een bericht in {channel.mention}", color=disnake.Color.purple())
        embed.set_author(name=payload.author.name, icon_url=payload.author.avatar)
        channel_to_send = self.bot.get_channel(env_variable.ADJE_LOG_CHANNEL_ID)
        try:
            if payload.attachments[0] != None:
                    embed.set_image(url=payload.attachments[0].proxy_url)
        except Exception as error:
            pass
        embed.add_field(name="Content:", value=str(payload.clean_content), inline=False)
        await channel_to_send.send(embed=embed)

    async def message_bulk_deleted(self, count, channel):

        channel_name = (await self.bot.fetch_channel(channel)).mention
        embed=disnake.Embed(title=f"\n", description=f"**Bulk berichten verwijderd in {channel_name} - Aantal: {count}**", color=disnake.Color.purple())
        channel_to_send = self.bot.get_channel(env_variable.ADJE_LOG_CHANNEL_ID)
        await channel_to_send.send(embed=embed)

    async def message_edited(self, before_content, after_content, channel, author):
        embed=disnake.Embed(title=f"\n", description=f"**Bericht bewerkt in {channel} - Door: {author.mention}**", color=disnake.Color.purple())
        embed.set_author(name=author, icon_url=author.avatar)
        embed.add_field(name="Voor het bewerken:", value=str(before_content), inline=False)
        embed.add_field(name="Na het bewerken:", value=str(after_content), inline=False)
        channel_to_send = self.bot.get_channel(env_variable.ADJE_LOG_CHANNEL_ID)
        await channel_to_send.send(embed=embed)



    # Roles
    async def new_or_deleted_role(self, role, type):
        embed=disnake.Embed(title=f"Rol {type}: {role}", description="\n", color=disnake.Color.purple())
        channel_to_send = self.bot.get_channel(env_variable.ADJE_LOG_CHANNEL_ID)
        await channel_to_send.send(embed=embed)

    async def edited_role(self, before, after):
        if str(before) != str(after):
            embed=disnake.Embed(title=f"Rol bewerkt", description="\n", color=disnake.Color.purple())
            embed.add_field(name="Voor het bewerken:", value=str(before), inline=False)
            embed.add_field(name="Na het bewerken:", value=str(after), inline=False)
            channel_to_send = self.bot.get_channel(env_variable.ADJE_LOG_CHANNEL_ID)
            await channel_to_send.send(embed=embed)
        else:
            pass

    async def color_change_role(self, before, after):
            embed=disnake.Embed(title=f"Rol {before.name} kleur bewerkt", description="\n", color=disnake.Color.purple())
            embed.add_field(name="Voor het bewerken:", value=str(before.color), inline=False)
            embed.add_field(name="Na het bewerken:", value=str(after.color), inline=False)
            channel_to_send = self.bot.get_channel(env_variable.ADJE_LOG_CHANNEL_ID)
            await channel_to_send.send(embed=embed)



    # Channels
    async def channel_change(self, channel, type="Nieuw kanaal"):
            embed=disnake.Embed(title=f"\n", description="**{type} met de naam: #{channel}**", color=disnake.Color.purple())
            channel_to_send = self.bot.get_channel(env_variable.ADJE_LOG_CHANNEL_ID)
            await channel_to_send.send(embed=embed)

    async def channel_name_change(self, before, after):
            embed=disnake.Embed(title=f"Kanaal bewerkt", description="\n", color=disnake.Color.purple())
            embed.add_field(name="Voor het bewerken:", value=str(before), inline=False)
            embed.add_field(name="Na het bewerken:", value=str(after), inline=False)
            channel_to_send = self.bot.get_channel(env_variable.ADJE_LOG_CHANNEL_ID)
            await channel_to_send.send(embed=embed)


    # Logging commands to log channel
    def log_commands(self, inter, command, on_user):
            embed=disnake.Embed(title=f"Adje log", description="\n", color=disnake.Color.purple())
            embed.set_author(name=inter.author, icon_url=inter.author.avatar)
            embed.add_field(name="Command:", value=str(command), inline=False)
            embed.add_field(name="Op gebruiker:", value=str(on_user), inline=False)
            channel_to_send = self.bot.get_channel(env_variable.ADJE_LOG_CHANNEL_ID)
            self.bot.loop.create_task(channel_to_send.send(embed=embed))




def setup(bot: commands.Bot):
    bot.add_cog(log_to_server(bot))