import discord, time, datetime, random, os
from discord import app_commands
from discord.ext import commands, tasks
from config import slova, sus_responses, greetings, main_channels_ids, bot_messages, bot_reply_messages

t_h = 0
t_s = 0

client = commands.Bot(command_prefix="~", intents=discord.Intents.all())
dtime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

##############################################################################################################
########################################## FUNCTIONS SCRIPTS #################################################
##############################################################################################################
async def chat_participation():              #randmonly sends messages into main channels function
    for idd in main_channels_ids:
            channel = client.get_channel(idd)

            print("jo")
            
            members = channel.members
            members_ids = []
            for member in members:
                members_ids.append(member.id)
            members_ids.remove(client.user.id)
            rnid = random.choice(members_ids)
            
            msg = (random.choice(bot_messages)).strip()
            
            if "@random" in msg:
                msg = msg.replace("@random", f"<@{rnid}>")
                
            if "<time>" in msg:
                msg = msg.replace("<time>", str(time.strftime("%H:%M:%S",time.localtime())))
                
            await channel.send(msg)
            print("|RAND CHAT PARTICIPATION| Bot sent: {}".format(msg))
#
#
#
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
async def word_counter(message):                    #counts words in word list function
    for slovo in slova:
        if slovo in message.content.lower().split(" ") and message.content[0] != '~':

            msg_author_id = str(message.author.id)

            count = message.content.lower().count(slovo)

            file_path = str("word_counts/" + slovo + '_' + msg_author_id + ".txt")

            if os.path.exists(file_path):
                pass

            else:
                file = open(file_path, 'w')
                file.write("0")
                file.close()

            pocet = open(file_path, 'r').read()
            pocet = int(pocet) + count
            file = open(file_path, 'w')
            file.write(str(pocet))
            file.close()
            print("|WORD COUNTER| Added {} to {}, in total: {}".format(count, file_path, open(file_path, "r").read()))

        else:
            pass

#
#
#
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
async def greetings_function(message):                 #greetings function
    global t_h
    if t_h + 30 < time.time():
        for g in greetings:
            if message.content.lower().startswith(g):
                await message.channel.send(random.choice(greetings))
                print('|GREETINGS| Expressed greetings to: {} (id: {})'.format(message.author.name, message.author.id))
                t_h = time.time()
            else:
                pass
    else:
        pass

#
#
#
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
async def sus_function(message):                        #sus function
    global t_s
    if t_s + 20 < time.time():
        if ('sus') in (message.content).lower() and message.content[0] != '~':
            await message.channel.send(sus_responses[random.randrange(0,len(sus_responses))])
            print('|SUS FUNC| Detected sus from: {} (id: {})'.format(message.author.name, message.author.id))
            t_s = time.time()
        else:
            pass
    else:
        pass

##############################################################################################################
########################################## RUNNING THE FUNCTIONS #############################################
##############################################################################################################

@tasks.loop(minutes = 10)
async def myloop():
    if random.randrange(0,1200) == random.randrange(0,1200):
        await chat_participation()

@client.event
async def on_ready():
    print(f"[ONREADY ] logged in as: {client.user}")

    try:
        synced = await client.tree.sync()
        print(f"[ONREADY ] synced {len(synced)} command(s)")

    except Exception as e:
        print(f"[ONREADY ] {e}")
    
    myloop.start()


@client.event                                       #on message actions
async def on_message(message):
    if message.author == client.user or message.channel.id not in main_channels_ids:
        return
        
    else:
        if client.user.mentioned_in(message) and "@here" not in message.content:
            reply = (random.choice(bot_reply_messages)).strip()
            if "<mentioner_message>" in reply:
                reply = reply.replace("<mentioner_message>", ("'" + message.content + "'"))
            await message.reply(reply)
            print("|REPLIED| Bot replied: {}".format(reply))
        else:
            await greetings_function(message)
            await sus_function(message)
            await word_counter(message)
            
            await client.process_commands(message)      #this line is very fuqacking important
        
##############################################################################################################
############################################# COMMANDS #######################################################
##############################################################################################################

#read word count - count reader     #count command returns message with counts of given word of all users
@client.tree.command(name="count", description="Reads the count of given word")
@app_commands.describe(word = "How many times has users written this word")
async def count(interaction: discord.Interaction, word: str):
    files = []
    user_counts = []
    msg = ''
    slovo = word

    if slovo in slova:
        directory = os.walk('word_counts')

        for file_path in directory:
            for path in file_path[2]:

                if path.split("_")[0] == slovo:
                        files.append(path)

                else:
                    pass
    else:
        print('|COUNT READER| Searched word is not in word list')
        await interaction.response.send_message('your desired word is not in word list')
        return

    if files == []:
        print('|COUNT READER| Word is in the list, but there are no records')
        await interaction.response.send_message('your desired word is in the list, but there are no records')
        return

    else:
        for filey in files:

            split_filey = filey.split('_')

            userid = split_filey[1].split('.')
            userid = userid[0]

            path = 'word_counts/' + filey
            usercount = open(path, 'r').read()

            user = client.get_user(int(userid)) #needs to be where the client runs (main.py)

            user_counts.append([user.name, int(usercount)])

    user_counts.sort(key=lambda x:x[1])

    for g in range(len(user_counts)):
        g = len(user_counts) - g - 1
        msg += str(user_counts[g][0]) + '  --->  ' + str(user_counts[g][1]) + '\n'

    await interaction.response.send_message(msg)

#
#
#epoch time script
@client.tree.command(name="etime", description="Shows epoch time")
async def count(interaction: discord.Interaction):      
    await interaction.response.send_message(f"the epoch time is: {time.time()} and the human time is: {dtime}")

#
#
#primenum command
@client.tree.command(name="primenum", description="Identifies whether given number is a primenumber")
@app_commands.describe(number = "Number to indentify it's divisibility")
async def primenum(interaction: discord.Interaction, number: int):                          
    delitel = 1
    vst_up = int(number / 2) #vstup děleno dvěmi
    nasel = 0
    print(f'|PRIMENUM| Input: {number}')

    if number >= 999999:
        answer = 'Too big number.'
        nasel = 3

    elif number == 2:
        answer = str(f'\nNumber {number} IS a prime number.')


    else:
        vystup = str(f'Number {number} is divisible by:')
        while delitel <= vst_up:
            delitel = delitel + 1
            deleno = number / delitel

            if deleno == int(deleno):
                if delitel == 2:
                    answer = str('Number %d is divisible by two...' % (number))
                    nasel = 3
                    break
                vystup = vystup + "\n " + str(int(deleno))
                nasel = 1

    if nasel == 0:
        answer = str('Number %d IS a prime number.' % (number))

    elif nasel == 1:
        answer = vystup + str('\nNumber %d IS NOT a prime number.' % (number))

    await interaction.response.send_message(answer)
    print('|PRIMENUM| Bot sent: {}'.format(answer))

#
#
#scientists prove that
@client.tree.command(name="scprove", description="Scientists will prove it")
@app_commands.describe(statement = "Short statement scientists will prove")
async def scprove(interaction: discord.Interaction, statement: str):                
      output = str('Scientists prove that ') + statement
      print('|SCPROVE| Bot sent: {}'.format(output))
      await interaction.channel.send(output)
      await interaction.response.send_message("Scientists have proven your statement", ephemeral=True)

#
#
#help command
@client.tree.command(name="help", description="List of bot commands and functions")
async def help(interaction: discord.Interaction):                      #help script
    #commands embed
    commands = client.tree.get_commands()
    embed1 = discord.Embed(title=":sparkles: Help :sparkles:", description=f"List of functions and commands", color=0xe10077)
    for c in commands:
        embed1.add_field(name=f"/{c.name}", value=c.description, inline=False)

    embed1.add_field(name = "Functions:", value = "-- Well behaved", inline = False)

    #embed1.add_field(name = "Well behaved", value="Bot will greet you back", inline = False)
    embed1.add_field(name = " ", value = " -- Significant recognicition of sussyness", inline = False)
    embed1.add_field(name = " ", value = " -- Word counting ability", inline = False)
    
    
    await interaction.response.send_message(embed = embed1)


############################################# RUNNING THE BOT ################################################
TOKEN = open("../sus_bot_token.txt", 'r').read()
client.run(TOKEN)