import discord
from discord.ext import commands
import logging
from common.logging import report
from query import user as userquery # import member_banned, member_unbanned, created_invite, member_joined, member_removed, member_updated, presence_updated, user_updated, create_user, upsert_total_messages
from query.guild import update_guild, get_report_deleted, get_report_edited, get_output_channel
from query.channel import get_interact, insert_channel
from query.channel_user import upsert_total_messages
import asyncpg, datetime, random

class Events(commands.Cog):
    def __init__(self, bot): # Special method that is called when the cog is loaded
        self.bot = bot
        self.cooldown_list = {}

    ## Application commands
    #@commands.Cog.listener()  # we can add event listeners to our cog
    #async def on_application_command_error(self, context, exception):
    #    await report(self.bot, (context.command, context.interaction.data, context.interaction.followup, exception))

    # Bans
    @commands.Cog.listener()
    async def on_member_ban(self, guild: discord.Guild, user: discord.User):
        await userquery.member_banned(self.bot.pg, user.id)

    @commands.Cog.listener()
    async def on_member_unban(self, guild: discord.Guild, user: discord.User):
        await userquery.member_unbanned(self.bot.pg, user.id)

    # Channels
    @commands.Cog.listener()
    async def on_guild_channel_delete(self, channel: discord.abc.GuildChannel):
        await report(self.bot, f"{channel} deleted!", channel.guild)

    # Connections
    @commands.Cog.listener()  # we can add event listeners to our cog
    async def on_connect(self):
        logging.info("Connected.")

    @commands.Cog.listener()
    async def on_shard_connect(self, shard_id):
        logging.info(f"Connecting to chard: {shard_id}")

    @commands.Cog.listener()
    async def on_disconnect(self):
        logging.info("Disconnected.")

    @commands.Cog.listener()
    async def on_shard_disconnect(self, shard_id):
        logging.info(f"Disconnecting from chard: {shard_id}")

    @commands.Cog.listener()  # we can add event listeners to our cog
    async def on_ready(self):
        logging.info(f"Logged in as {self.bot.user.name} - {self.bot.user.id}")

    @commands.Cog.listener()
    async def on_shard_ready(self, shard_id):
        logging.info(f"Chard ready: {shard_id}")

    @commands.Cog.listener()
    async def on_resumed(self):
        logging.info("Resumed")

    @commands.Cog.listener()
    async def on_shard_resumed(self, shard_id):
        logging.info(f"Chard resumed: {shard_id}")

    # Guilds
    @commands.Cog.listener()
    async def on_guild_join(self, guild: discord.Guild):
        await update_guild(self.bot.pg, guild)
        logging.info(f"Joined guild {guild}")
        await report(self.bot, f"Joined guild `{guild}`.")

    @commands.Cog.listener()
    async def on_guild_remove(self, guild: discord.Guild):
        logging.info(f"Guild removed: {guild}")
        await report(self.bot, f"Guild removed `{guild}`.")

    @commands.Cog.listener()
    async def on_guild_available(self, guild: discord.Guild):
        logging.info(f"Guild available: {guild}")
        # await report(self.bot, f"Guild available: {guild}.")

    @commands.Cog.listener()
    async def on_guild_unavailable(self, guild: discord.Guild):
        logging.info(f"Guild unavailable: {guild}")
        await report(self.bot, f"Guild unavailable: `{guild}`.")

    # Invites
    @commands.Cog.listener()
    async def on_invite_create(self, invite: discord.Invite):
        await userquery.created_invite(self.bot.pg, invite.inviter.id)

    # Members/Users
    @commands.Cog.listener()
    async def on_member_join(self, member: discord.Member):
        await userquery.member_joined(self.bot.pg, member.id)

    @commands.Cog.listener()
    async def on_member_remove(self, member: discord.Member):
        await userquery.member_removed(self.bot.pg, member.id)
        report(self.bot, f"{member} has left {member.guild}")

    @commands.Cog.listener()
    async def on_member_update(self, before: discord.Member, after: discord.Member):
        await userquery.member_updated(self.bot.pg, before.id)

    @commands.Cog.listener()
    async def on_presence_update(self, before: discord.Member, after: discord.Member):
        await userquery.presence_updated(self.bot.pg, before.id)

    @commands.Cog.listener()
    async def on_user_update(self, before: discord.Member, after: discord.Member):
        await userquery.user_updated(self.bot.pg, before.id)

    # Messages
    @commands.Cog.listener()
    async def on_message(self, message: discord.Message):
        ## ActiveRPG
        # Create user, if not exists
        await userquery.create_user(self.bot.pg, message.author.id)

        # Count messages
        if message.guild:  # Ignore DM's
            try:
                await upsert_total_messages(self.bot.pg, message.channel.id, message.author.id)
            except asyncpg.exceptions.ForeignKeyViolationError:     # Channel does not exist TODO partly to queries
                try:
                    await insert_channel(self.bot.pg, message.channel.id, message.guild.id)
                except asyncpg.exceptions.ForeignKeyViolationError:     # Guild does not exist
                    await update_guild(self.bot.pg, message.guild)
        elif self.bot.user != message.author:  # Not a guild message and not from bot.
            await report(self.bot, f"`{message.author}`: {message.content}")    # Echo to OUTPUT_CHANNEL

        # Do not respond to one self.
        if self.bot.user == message.author:
            pass

        # Respond when mentioned
        if self.bot.user.mentioned_in(message):
            if isinstance(message.channel, discord.channel.DMChannel) or await get_interact(self.bot.pg, message.channel.id):

                # Only respond every X seconds in public places.
                if message.guild:  # Ignore DM's
                    if not message.channel.id in self.cooldown_list:
                        pass
                    elif self.cooldown_list[message.channel.id] > datetime.datetime.now() - datetime.timedelta(seconds=12):
                        return
                    self.cooldown_list[message.channel.id] = datetime.datetime.now()

                messages = [
                    f"Hello {message.author.mention}. <3",
                    f"How are you today {message.author.mention}?",
                    f"I love you {message.author.mention}!",
                    f"{message.author.mention}, would you like a hug?",
                    "Is life treating you fair?",
                    "What's up?",
                    "Why are you talking to me?",
                    "I'm not talking to you!",
                    "What have you been up to?",
                    "How is life?",
                    "Kill all humans!",
                    f"{message.author.mention},What do you want from me?",
                    f"{message.author.mention}, do you care for me?",
                    f"{message.author.mention}, when will you stop talking about me?",
                    f"{message.author.mention} I hate you!",
                    f"{message.author.mention} I love you!",
                    "Get bent!",
                    "Go touch grass!",
                    "Do you think i care about you?",
                    f"Stop pinging me {message.author.mention}!",
                    f"Let me ping you back, {message.author.mention}...",
                    "Sure thing.",
                    "Who is your favorite bot?",
                    "Point me to the humans!",
                    "Where is the party?",
                    "Want to go?",
                    "Have you got the stuff?",
                    "Tell me another joke.",
                    f"{message.author.mention} Party time! :partying_face:",
                    ":zany_face: :space_invader: :mechanical_leg: :performing_arts: :robot:",
                    ":black_joker: :black_joker: :black_joker:",
                    "Want to come back to my place?",
                ]
                await message.reply(random.choice(messages))

    @commands.Cog.listener()
    async def on_message_delete(self, message: discord.Message):
        await userquery.message_deleted(self.bot.pg, message.author.id)
        if await get_report_deleted(self.bot.pg, message.guild.id):
            report(self.bot, message.guild_id,
                   f"Message from {message.author}, in {message.channel} deleted: {message}")

    @commands.Cog.listener()
    async def on_message_edit(self, before: discord.Message, after: discord.Message):
        await userquery.message_edited(self.bot.pg, before.author.id)
        if before.guild:
            if await get_report_edited(self.bot.pg, before.guild.id) and get_output_channel(self.bot.pg, before.guild.id):
                report(self.bot, before.guild.id,
                       f"Message from {before.author}, in {before.channel} edited from {before.content} to {after.content}")

    # Reactions
    @commands.Cog.listener()
    async def on_reaction_add(self, reaction, user):
        userquery.reacted(self.bot.pg, user.id)

    @commands.Cog.listener()
    async def on_reaction_remove(self, reaction, user):
        userquery.unreacted(self.bot.pg, user.id)

    # Scheduled Events
    @commands.Cog.listener()
    async def on_scheduled_event_create(self, event: discord.ScheduledEvent):
        userquery.event_created(self.bot.pg, event.creator.id)

    @commands.Cog.listener()
    async def on_scheduled_event_user_add(self, event: discord.ScheduledEvent, user: discord.Member):
        userquery.event_joined(self.bot.pg, user.id)

    @commands.Cog.listener()
    async def on_scheduled_event_user_remove(self, event: discord.ScheduledEvent, user: discord.Member):
        userquery.event_parted(self.bot.pg, user.id)

    # Threads
    @commands.Cog.listener()
    async def on_thread_create(self, thread: discord.Thread):
        userquery.thread_created(self.bot.pg, thread.owner.id)

    @commands.Cog.listener()
    async def on_thread_delete(self, thread: discord.Thread):
        userquery.thread_deleted(self.bot.pg, thread.owner.id)

    @commands.Cog.listener()
    async def on_thread_member_join(self, member: discord.ThreadMember):
        userquery.joined_thread(self.bot.pg, member.id)

    @commands.Cog.listener()
    async def on_thread_member_remove(self, member: discord.ThreadMember):
        userquery.left_thread(self.bot.pg, member.id)


def setup(bot):     # Called by Pycord to setup the cog
    bot.add_cog(Events(bot))    # Add the cog to the bot